diff --git a/frontend/src/app/views/new-header/new-header.component.html b/frontend/src/app/views/new-header/new-header.component.html
index b19bcc42d1..3c5168422e 100644
--- a/frontend/src/app/views/new-header/new-header.component.html
+++ b/frontend/src/app/views/new-header/new-header.component.html
@@ -71,7 +71,11 @@
 
 <ng-template #footerBar>
     <div id="footerBar">
-        <div class="item doc-widget-toggle" (click)="toggleDocWidget()">
+        <div class="item doc-widget-toggle"
+             [class.doc-widget-toggle--disabled]="!docWidgetAvailable"
+             [pTooltip]="docWidgetAvailable ? '' : 'Documentation is only available over HTTPS'"
+             tooltipPosition="right"
+             (click)="toggleDocWidget()">
             <svg-icon
                 class="svg-icon-16 open-book-icon"
                 src="/assets/images/icons/book-open.svg"
@@ -79,10 +83,10 @@
             </svg-icon>
             <div [class.hidden-logotype]="menuCollapsed" class="span-icon">
                 <span>Documentation</span>
-                <div class="doc-toggle" [class.doc-toggle--active]="showDocWidget">
+                <div class="doc-toggle" [class.doc-toggle--active]="showDocWidget && docWidgetAvailable">
                     <div class="doc-toggle__thumb">
                         <svg-icon
-                            *ngIf="showDocWidget"
+                            *ngIf="showDocWidget && docWidgetAvailable"
                             src="/assets/images/icons/check-fill.svg"
                             class="check-fill-icon-wrapper"
                             svgClass="icon-color-secondary check-fill-icon">
diff --git a/frontend/src/app/views/new-header/new-header.component.scss b/frontend/src/app/views/new-header/new-header.component.scss
index 7adcc1c15c..73be0d209c 100644
--- a/frontend/src/app/views/new-header/new-header.component.scss
+++ b/frontend/src/app/views/new-header/new-header.component.scss
@@ -394,6 +394,11 @@
     cursor: pointer;
     background: #FFFFFF3D;
     border: 1px solid #FFFFFF52;
+
+    &--disabled {
+        cursor: not-allowed;
+        opacity: 0.5;
+    }
 }
 
 .doc-toggle {
diff --git a/frontend/src/app/views/new-header/new-header.component.ts b/frontend/src/app/views/new-header/new-header.component.ts
index bb56ad622a..d4df01fd70 100644
--- a/frontend/src/app/views/new-header/new-header.component.ts
+++ b/frontend/src/app/views/new-header/new-header.component.ts
@@ -31,6 +31,7 @@ export class NewHeaderComponent implements OnInit, AfterViewChecked {
     public policyRequests = 0;
     public newPolicyRequests = 0;
     public showDocWidget: boolean = true;
+    public readonly docWidgetAvailable: boolean = window.location.protocol === 'https:';
 
     private commonLinksDisabled: boolean = false;
     private balanceType: string;
@@ -256,6 +257,9 @@ export class NewHeaderComponent implements OnInit, AfterViewChecked {
     }
 
     public toggleDocWidget() {
+        if (!this.docWidgetAvailable) {
+            return;
+        }
         this.showDocWidget = !this.showDocWidget;
 
         try {
diff --git a/frontend/src/index.html b/frontend/src/index.html
index fd215a8432..a22721d876 100644
--- a/frontend/src/index.html
+++ b/frontend/src/index.html
@@ -18,404 +18,407 @@
 
 <body class="mat-typography">
     <app-root></app-root>
-    <script src="https://guardian.hedera.com/~gitbook/embed/script.js"></script>
     <script>
-        try {
-            window.GitBook('unload');
-        } catch (e) {
-            console.error(e);
-        }
-        window.GitBook('init', { siteURL: 'https://guardian.hedera.com' });
-        window.GitBook('configure', {
-            button: { label: 'See Docs', icon: 'assistant' },
-            tabs: ['assistant', 'docs']
-        });
-        window.GitBook('show');
-    </script>
-    <script>
-        const STORAGE_KEY = 'gitbook-widget-pos';
-        const BUTTON_ID = 'gitbook-widget-button';
-        const WINDOW_ID = 'gitbook-widget-window';
-
-        const GAP = 12;
-        const DRAG_SIZE = 3;
-
-        const isButtonVisible = (btn) => {
-            if (!btn || !btn.isConnected) {
-                return false;
-            }
-
-            const cs = getComputedStyle(btn);
-
-            if (cs.display === 'none' || cs.visibility === 'hidden' || Number(cs.opacity) === 0) {
-                return false;
-            }
-
-            const r = btn.getBoundingClientRect();
-            return r.width > 0 && r.height > 0;
-        };
-
-        const getMin = (value, min, max) => Math.min(max, Math.max(min, value));
-
-        const setStyles = (el, styles) => {
-            for (const [prop, val] of Object.entries(styles)) {
-                el.style.setProperty(prop, String(val), 'important');
-            }
-        };
-
-        const getWindowEl = () => document.getElementById(WINDOW_ID);
-        const getButtonEl = () => document.getElementById(BUTTON_ID);
-
-        const readSavedPosition = () => {
-            try {
-                const raw = localStorage.getItem(STORAGE_KEY);
-                if (!raw) return null;
-                const parsed = JSON.parse(raw);
-                const x = Number(parsed?.x);
-                const y = Number(parsed?.y);
-                return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
-            } catch {
-                return null;
-            }
-        };
-
-        const savePosition = (x, y) => {
-            try {
-                localStorage.setItem(STORAGE_KEY, JSON.stringify({ x, y }));
-            } catch (err) {
-                console.error(err);
-            }
-        };
-
-        const constrainPosition = (btn, x, y) => {
-            const rect = btn.getBoundingClientRect();
-            const viewport = { w: window.innerWidth, h: window.innerHeight };
-            
-            const maxX = viewport.w - rect.width;
-            const maxY = viewport.h - rect.height;
-            
-            return {
-                x: getMin(x, 0, maxX),
-                y: getMin(y, 0, maxY)
-            };
-        };
+        if (window.location.protocol === 'https:') {
+            const STORAGE_KEY = 'gitbook-widget-pos';
+            const BUTTON_ID = 'gitbook-widget-button';
+            const WINDOW_ID = 'gitbook-widget-window';
+            const TARGET_IFRAME_ID = 'gitbook-widget-iframe';
+            const GAP = 12;
+            const DRAG_SIZE = 3;
+            const processed = new WeakSet();
+
+            const isButtonVisible = (btn) => {
+                if (!btn || !btn.isConnected) {
+                    return false;
+                }
+
+                const cs = getComputedStyle(btn);
 
-        const applyButtonPosition = (btn, x, y) => {
-            btn.style.position = 'fixed';
-            btn.style.right = 'auto';
-            btn.style.bottom = 'auto';
-            btn.style.left = `${x}px`;
-            btn.style.top = `${y}px`;
-        };
+                if (cs.display === 'none' || cs.visibility === 'hidden' || Number(cs.opacity) === 0) {
+                    return false;
+                }
 
-        const getViewport = () => ({ w: window.innerWidth, h: window.innerHeight });
+                const r = btn.getBoundingClientRect();
+                return r.width > 0 && r.height > 0;
+            };
 
-        const getWidgetSize = (windowElement) => ({
-            w: windowElement.offsetWidth || 400,
-            h: windowElement.offsetHeight || 600,
-        });
+            const getMin = (value, min, max) => Math.min(max, Math.max(min, value));
 
-        const placeWidgetNearButton = (btn) => {
-            requestAnimationFrame(() => {
-                const windowElement = getWindowEl();
-                if (!windowElement) {
-                    return;
+            const setStyles = (el, styles) => {
+                for (const [prop, val] of Object.entries(styles)) {
+                    el.style.setProperty(prop, String(val), 'important');
                 }
+            };
 
-                if (!isButtonVisible(btn)) {
-                    return;
+            const getWindowEl = () => document.getElementById(WINDOW_ID);
+            const getButtonEl = () => document.getElementById(BUTTON_ID);
+
+            const readSavedPosition = () => {
+                try {
+                    const raw = localStorage.getItem(STORAGE_KEY);
+                    if (!raw) return null;
+                    const parsed = JSON.parse(raw);
+                    const x = Number(parsed?.x);
+                    const y = Number(parsed?.y);
+                    return Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+                } catch {
+                    return null;
                 }
+            };
 
-                setStyles(windowElement, {
-                    position: 'fixed',
-                    top: 0,
-                    left: 0,
-                    right: 'auto',
-                    bottom: 'auto',
-                    margin: 0,
-                });
+            const savePosition = (x, y) => {
+                try {
+                    localStorage.setItem(STORAGE_KEY, JSON.stringify({ x, y }));
+                } catch (err) {
+                    console.error(err);
+                }
+            };
 
-                const { w: vw, h: vh } = getViewport();
-                const { w: ww, h: wh } = getWidgetSize(windowElement);
-                const r = btn.getBoundingClientRect();
+            const constrainPosition = (btn, x, y) => {
+                const rect = btn.getBoundingClientRect();
+                const viewport = { w: window.innerWidth, h: window.innerHeight };
 
-                const cx = r.left + r.width / 2;
-                const cy = r.top + r.height / 2;
+                const maxX = viewport.w - rect.width;
+                const maxY = viewport.h - rect.height;
 
-                const belowTop = r.bottom + GAP;
-                const aboveTop = r.top - GAP - wh;
-                const rightLeft = r.right + GAP;
-                const leftLeft = r.left - GAP - ww;
+                return {
+                    x: getMin(x, 0, maxX),
+                    y: getMin(y, 0, maxY)
+                };
+            };
 
-                const fitsBelow = belowTop + wh <= vh;
-                const fitsAbove = aboveTop >= 0;
-                const fitsRight = rightLeft + ww <= vw;
-                const fitsLeft = leftLeft >= 0;
+            const applyButtonPosition = (btn, x, y) => {
+                btn.style.position = 'fixed';
+                btn.style.right = 'auto';
+                btn.style.bottom = 'auto';
+                btn.style.left = `${x}px`;
+                btn.style.top = `${y}px`;
+            };
 
-                const alignedLeft = getMin(r.left, 0, vw - ww);
-                const alignedTop = getMin(r.top, 0, vh - wh);
+            const getViewport = () => ({ w: window.innerWidth, h: window.innerHeight });
 
-                const preferRight = cx < vw / 2;
-                const sideFits = preferRight ? fitsRight : fitsLeft;
-                const sideLeft = preferRight ? rightLeft : leftLeft;
+            const getWidgetSize = (windowElement) => ({
+                w: windowElement.offsetWidth || 400,
+                h: windowElement.offsetHeight || 600,
+            });
 
-                const candidates = [];
+            const placeWidgetNearButton = (btn) => {
+                requestAnimationFrame(() => {
+                    const windowElement = getWindowEl();
+                    if (!windowElement) {
+                        return;
+                    }
 
-                const push = (isPossible, left, top) => {
-                    if (!isPossible) {
+                    if (!isButtonVisible(btn)) {
                         return;
                     }
 
-                    candidates.push({
-                        left: getMin(left, 0, vw - ww),
-                        top: getMin(top, 0, vh - wh),
+                    setStyles(windowElement, {
+                        position: 'fixed',
+                        top: 0,
+                        left: 0,
+                        right: 'auto',
+                        bottom: 'auto',
+                        margin: 0,
                     });
-                };
 
-                if (cy < vh / 2) {
-                    push(fitsBelow, alignedLeft, belowTop);
-                    push(fitsAbove, alignedLeft, aboveTop);
-                    push(sideFits, sideLeft, alignedTop);
-                } else {
-                    push(fitsAbove, alignedLeft, aboveTop);
-                    push(fitsBelow, alignedLeft, belowTop);
-                    push(sideFits, sideLeft, alignedTop);
-                }
-
-                if (candidates.length === 0) {
-                    const fallbackLeft = getMin(preferRight ? leftLeft : rightLeft, 0, vw - ww);
-                    candidates.push({ left: fallbackLeft, top: alignedTop });
-                }
+                    const { w: vw, h: vh } = getViewport();
+                    const { w: ww, h: wh } = getWidgetSize(windowElement);
+                    const r = btn.getBoundingClientRect();
+
+                    const cx = r.left + r.width / 2;
+                    const cy = r.top + r.height / 2;
+
+                    const belowTop = r.bottom + GAP;
+                    const aboveTop = r.top - GAP - wh;
+                    const rightLeft = r.right + GAP;
+                    const leftLeft = r.left - GAP - ww;
+
+                    const fitsBelow = belowTop + wh <= vh;
+                    const fitsAbove = aboveTop >= 0;
+                    const fitsRight = rightLeft + ww <= vw;
+                    const fitsLeft = leftLeft >= 0;
+
+                    const alignedLeft = getMin(r.left, 0, vw - ww);
+                    const alignedTop = getMin(r.top, 0, vh - wh);
+
+                    const preferRight = cx < vw / 2;
+                    const sideFits = preferRight ? fitsRight : fitsLeft;
+                    const sideLeft = preferRight ? rightLeft : leftLeft;
+
+                    const candidates = [];
+
+                    const push = (isPossible, left, top) => {
+                        if (!isPossible) {
+                            return;
+                        }
+
+                        candidates.push({
+                            left: getMin(left, 0, vw - ww),
+                            top: getMin(top, 0, vh - wh),
+                        });
+                    };
+
+                    if (cy < vh / 2) {
+                        push(fitsBelow, alignedLeft, belowTop);
+                        push(fitsAbove, alignedLeft, aboveTop);
+                        push(sideFits, sideLeft, alignedTop);
+                    } else {
+                        push(fitsAbove, alignedLeft, aboveTop);
+                        push(fitsBelow, alignedLeft, belowTop);
+                        push(sideFits, sideLeft, alignedTop);
+                    }
 
-                const { left, top } = candidates[0];
-                setStyles(windowElement, { left: `${left}px`, top: `${top}px` });
-            });
-        };
+                    if (candidates.length === 0) {
+                        const fallbackLeft = getMin(preferRight ? leftLeft : rightLeft, 0, vw - ww);
+                        candidates.push({ left: fallbackLeft, top: alignedTop });
+                    }
 
-        const observeWidgetVisibility = (btn, windowElement) => {
-            const observer = new MutationObserver(() => {
-                const styles = getComputedStyle(windowElement);
+                    const { left, top } = candidates[0];
+                    setStyles(windowElement, { left: `${left}px`, top: `${top}px` });
+                });
+            };
 
-                if (styles.display !== 'none' && styles.visibility !== 'hidden') {
-                    placeWidgetNearButton(btn);
-                }
-            });
+            const observeWidgetVisibility = (btn, windowElement) => {
+                const observer = new MutationObserver(() => {
+                    const styles = getComputedStyle(windowElement);
 
-            observer.observe(windowElement, { attributes: true, attributeFilter: ['style', 'class'] });
-        };
+                    if (styles.display !== 'none' && styles.visibility !== 'hidden') {
+                        placeWidgetNearButton(btn);
+                    }
+                });
 
-        const waitForElementById = (id, onFound) => {
-            const existing = document.getElementById(id);
+                observer.observe(windowElement, { attributes: true, attributeFilter: ['style', 'class'] });
+            };
 
-            if (existing) {
-                onFound(existing);
-                return;
-            }
+            const waitForElementById = (id, onFound) => {
+                const existing = document.getElementById(id);
 
-            const observer = new MutationObserver(() => {
-                const element = document.getElementById(id);
-                if (!element) {
+                if (existing) {
+                    onFound(existing);
                     return;
                 }
-                observer.disconnect();
-                onFound(element);
-            });
 
-            observer.observe(document.body, { childList: true, subtree: true });
-        };
-
-        const setupDrag = (btn) => {
-            const rect = btn.getBoundingClientRect();
-            const startPos = constrainPosition(btn, rect.left, Math.max(0, rect.top - 50));
-            applyButtonPosition(btn, startPos.x, startPos.y);
-
-            const saved = readSavedPosition();
-            if (saved) {
-                const constrained = constrainPosition(btn, saved.x, saved.y);
-                applyButtonPosition(btn, constrained.x, constrained.y);
-            }
-
-            let dragActive = false;
-            let moved = false;
-            let clickBlockOnce = false;
-
-            let startX = 0;
-            let startY = 0;
-            let originLeft = 0;
-            let originTop = 0;
-
-            document.addEventListener(
-                'click',
-                (e) => {
-                    if (!clickBlockOnce) {
+                const observer = new MutationObserver(() => {
+                    const element = document.getElementById(id);
+                    if (!element) {
                         return;
                     }
-                    if (e.target === btn || btn.contains(e.target)) {
-                        clickBlockOnce = false;
-                        e.stopPropagation();
-                        e.preventDefault();
-                    }
-                },
-                true
-            );
+                    observer.disconnect();
+                    onFound(element);
+                });
 
-            btn.addEventListener('mousedown', (e) => {
-                e.preventDefault();
+                observer.observe(document.body, { childList: true, subtree: true });
+            };
 
-                const r = btn.getBoundingClientRect();
-                startX = e.clientX;
-                startY = e.clientY;
-                originLeft = r.left;
-                originTop = r.top;
+            const setupDrag = (btn) => {
+                const rect = btn.getBoundingClientRect();
+                const startPos = constrainPosition(btn, rect.left, Math.max(0, rect.top - 50));
+                applyButtonPosition(btn, startPos.x, startPos.y);
 
-                dragActive = true;
-                moved = false;
+                const saved = readSavedPosition();
+                if (saved) {
+                    const constrained = constrainPosition(btn, saved.x, saved.y);
+                    applyButtonPosition(btn, constrained.x, constrained.y);
+                }
 
-                btn.style.transition = 'none';
-                btn.style.userSelect = 'none';
-            });
+                let dragActive = false;
+                let moved = false;
+                let clickBlockOnce = false;
+
+                let startX = 0;
+                let startY = 0;
+                let originLeft = 0;
+                let originTop = 0;
+
+                document.addEventListener(
+                    'click',
+                    (e) => {
+                        if (!clickBlockOnce) {
+                            return;
+                        }
+                        if (e.target === btn || btn.contains(e.target)) {
+                            clickBlockOnce = false;
+                            e.stopPropagation();
+                            e.preventDefault();
+                        }
+                    },
+                    true
+                );
+
+                btn.addEventListener('mousedown', (e) => {
+                    e.preventDefault();
+
+                    const r = btn.getBoundingClientRect();
+                    startX = e.clientX;
+                    startY = e.clientY;
+                    originLeft = r.left;
+                    originTop = r.top;
+
+                    dragActive = true;
+                    moved = false;
+
+                    btn.style.transition = 'none';
+                    btn.style.userSelect = 'none';
+                });
 
-            document.addEventListener('mousemove', (e) => {
-                if (!dragActive) {
-                    return;
-                }
+                document.addEventListener('mousemove', (e) => {
+                    if (!dragActive) {
+                        return;
+                    }
 
-                const dragX = e.clientX - startX;
-                const dragY = e.clientY - startY;
+                    const dragX = e.clientX - startX;
+                    const dragY = e.clientY - startY;
 
-                if (Math.abs(dragX) <= DRAG_SIZE && Math.abs(dragY) <= DRAG_SIZE) {
-                    return;
-                }
+                    if (Math.abs(dragX) <= DRAG_SIZE && Math.abs(dragY) <= DRAG_SIZE) {
+                        return;
+                    }
 
-                moved = true;
+                    moved = true;
 
-                const constrained = constrainPosition(btn, originLeft + dragX, originTop + dragY);
-                applyButtonPosition(btn, constrained.x, constrained.y);
-            });
+                    const constrained = constrainPosition(btn, originLeft + dragX, originTop + dragY);
+                    applyButtonPosition(btn, constrained.x, constrained.y);
+                });
 
-            document.addEventListener('mouseup', () => {
-                if (!dragActive) {
-                    return;
-                }
+                document.addEventListener('mouseup', () => {
+                    if (!dragActive) {
+                        return;
+                    }
 
-                dragActive = false;
-                btn.style.userSelect = '';
+                    dragActive = false;
+                    btn.style.userSelect = '';
 
-                if (!moved) {
-                    return;
-                }
+                    if (!moved) {
+                        return;
+                    }
 
-                clickBlockOnce = true;
+                    clickBlockOnce = true;
 
-                const r = btn.getBoundingClientRect();
-                const finalPos = constrainPosition(btn, r.left, r.top);
-                applyButtonPosition(btn, finalPos.x, finalPos.y);
-                savePosition(finalPos.x, finalPos.y);
-            });
-        };
-
-
-        const observeButtonClasses = (btn) => {
-            const observer = new MutationObserver((mutations) => {
-                if (!btn.classList.contains('hidden')) {
-                    const rect = btn.getBoundingClientRect();
-                    const constrained = constrainPosition(btn, rect.left, rect.top);
-                    
-                    if (Math.abs(rect.left - constrained.x) > 1 || Math.abs(rect.top - constrained.y) > 1) {
-                        applyButtonPosition(btn, constrained.x - 15, constrained.y);
-                        savePosition(constrained.x, constrained.y);
+                    const r = btn.getBoundingClientRect();
+                    const finalPos = constrainPosition(btn, r.left, r.top);
+                    applyButtonPosition(btn, finalPos.x, finalPos.y);
+                    savePosition(finalPos.x, finalPos.y);
+                });
+            };
+
+            const observeButtonClasses = (btn) => {
+                const observer = new MutationObserver((mutations) => {
+                    if (!btn.classList.contains('hidden')) {
+                        const rect = btn.getBoundingClientRect();
+                        const constrained = constrainPosition(btn, rect.left, rect.top);
+
+                        if (Math.abs(rect.left - constrained.x) > 1 || Math.abs(rect.top - constrained.y) > 1) {
+                            applyButtonPosition(btn, constrained.x - 15, constrained.y);
+                            savePosition(constrained.x, constrained.y);
+                        }
                     }
+                })
+
+                observer.observe(btn, {
+                    attributes: true,
+                    attributeFilter: ['class']
+                });
+            };
+
+            const boot = (btn) => {
+                setupDrag(btn);
+                observeButtonClasses(btn);
+
+                const windowElement = getWindowEl();
+                if (windowElement) {
+                    observeWidgetVisibility(btn, windowElement);
+                    return;
                 }
-            })
-            
-            observer.observe(btn, { 
-                attributes: true, 
-                attributeFilter: ['class'] 
-            });
-        };
 
-        const boot = (btn) => {
-            setupDrag(btn);
-            observeButtonClasses(btn);
+                waitForElementById(WINDOW_ID, (wEl) => observeWidgetVisibility(btn, wEl));
+            };
 
-            const windowElement = getWindowEl();
-            if (windowElement) {
-                observeWidgetVisibility(btn, windowElement);
-                return;
-            }
+            const ensureClipboardWritePermission = (iframe) => {
+                const allow = (iframe.getAttribute('allow') || '').trim();
+                const tokens = allow
+                    .split(';')
+                    .map((t) => t.trim())
+                    .filter(Boolean);
 
-            waitForElementById(WINDOW_ID, (wEl) => observeWidgetVisibility(btn, wEl));
-        };
+                if (!tokens.includes('clipboard-write')) {
+                    tokens.push('clipboard-write');
+                    iframe.setAttribute('allow', tokens.join('; '));
+                }
+            };
 
-        const start = () => waitForElementById(BUTTON_ID, boot);
+            const reloadIframeByCloning = (iframe) => {
+                const clone = iframe.cloneNode(true);
+                processed.add(clone);
+                iframe.replaceWith(clone);
+            };
 
-        if (document.readyState === 'loading') {
-            window.addEventListener('DOMContentLoaded', start, { once: true });
-        } else {
-            start();
-        }
+            const patchTargetIframe = () => {
+                const el = document.getElementById(TARGET_IFRAME_ID);
 
-        window.addEventListener('resize', () => {
-            const btn = getButtonEl();
-            if (btn && isButtonVisible(btn)) {
-                const rect = btn.getBoundingClientRect();
-                const constrained = constrainPosition(btn, rect.left, rect.top);
-                if (Math.abs(rect.left - constrained.x) > 1 || Math.abs(rect.top - constrained.y) > 1) {
-                    applyButtonPosition(btn, constrained.x, constrained.y);
-                    savePosition(constrained.x, constrained.y);
+                if (!el || !(el instanceof HTMLIFrameElement)) {
+                    return;
                 }
-            }
-        });
-    </script>
-    <script>
-        const TARGET_IFRAME_ID = 'gitbook-widget-iframe';
-        const processed = new WeakSet();
-
-        function ensureClipboardWritePermission(iframe) {
-            const allow = (iframe.getAttribute('allow') || '').trim();
-            const tokens = allow
-                .split(';')
-                .map((t) => t.trim())
-                .filter(Boolean);
-
-            if (!tokens.includes('clipboard-write')) {
-                tokens.push('clipboard-write');
-                iframe.setAttribute('allow', tokens.join('; '));
-            }
-        }
 
-        function reloadIframeByCloning(iframe) {
-            const clone = iframe.cloneNode(true);
-            processed.add(clone);
-            iframe.replaceWith(clone);
-        }
+                if (processed.has(el)) {
+                    return;
+                }
 
-        function patchTargetIframe() {
-            const el = document.getElementById(TARGET_IFRAME_ID);
+                processed.add(el);
+                ensureClipboardWritePermission(el);
+                reloadIframeByCloning(el);
+            };
 
-            if (!el || !(el instanceof HTMLIFrameElement)) {
-                return;
-            }
+            const bootWidget = () => {
+                const start = () => waitForElementById(BUTTON_ID, boot);
 
-            if (processed.has(el)) {
-                return;
-            }
+                if (document.readyState === 'loading') {
+                    window.addEventListener('DOMContentLoaded', start, { once: true });
+                } else {
+                    start();
+                }
 
-            processed.add(el);
-            ensureClipboardWritePermission(el);
-            reloadIframeByCloning(el);
-        }
+                window.addEventListener('resize', () => {
+                    const btn = getButtonEl();
+                    if (btn && isButtonVisible(btn)) {
+                        const rect = btn.getBoundingClientRect();
+                        const constrained = constrainPosition(btn, rect.left, rect.top);
+                        if (Math.abs(rect.left - constrained.x) > 1 || Math.abs(rect.top - constrained.y) > 1) {
+                            applyButtonPosition(btn, constrained.x, constrained.y);
+                            savePosition(constrained.x, constrained.y);
+                        }
+                    }
+                });
 
-        patchTargetIframe();
+                patchTargetIframe();
+                const iframeObserver = new MutationObserver(patchTargetIframe);
+                iframeObserver.observe(document.documentElement, {
+                    childList: true,
+                    subtree: true,
+                    attributes: true,
+                    attributeFilter: ['id'],
+                });
+            };
 
-        const observer = new MutationObserver(patchTargetIframe);
-        observer.observe(document.documentElement, {
-            childList: true,
-            subtree: true,
-            attributes: true,
-            attributeFilter: ['id'],
-        });
+            const script = document.createElement('script');
+            script.src = 'https://guardian.hedera.com/~gitbook/embed/script.js';
+            script.onload = () => {
+                try {
+                    window.GitBook('unload');
+                } catch (e) {
+                    console.error(e);
+                }
+                window.GitBook('init', { siteURL: 'https://guardian.hedera.com' });
+                window.GitBook('configure', {
+                    button: { label: 'See Docs', icon: 'assistant' },
+                    tabs: ['assistant', 'docs']
+                });
+                window.GitBook('show');
+                bootWidget();
+            };
+            document.head.appendChild(script);
+        }
     </script>
 </body>
 
-</html>
\ No newline at end of file
+</html>
