diff --git a/admin/documentate-converter-template.php b/admin/documentate-converter-template.php
index adc2196..8339b81 100644
--- a/admin/documentate-converter-template.php
+++ b/admin/documentate-converter-template.php
@@ -20,16 +20,31 @@
 $nonce         = isset( $_GET['_wpnonce'] ) ? sanitize_text_field( wp_unslash( $_GET['_wpnonce'] ) ) : '';
 $use_channel   = isset( $_GET['use_channel'] ) && '1' === $_GET['use_channel'];
 
+// Iframe mode parameters (for WordPress Playground compatibility).
+$is_iframe_mode = isset( $_GET['mode'] ) && 'iframe' === sanitize_key( $_GET['mode'] );
+$parent_origin  = isset( $_GET['parent_origin'] ) ? esc_url_raw( wp_unslash( $_GET['parent_origin'] ) ) : '';
+$request_id     = isset( $_GET['request_id'] ) ? sanitize_text_field( wp_unslash( $_GET['request_id'] ) ) : '';
+
 // Helper and thread URLs are local, WASM loads from CDN.
 $helper_url = plugins_url( 'admin/vendor/zetajs/zetaHelper.js', DOCUMENTATE_PLUGIN_FILE );
 $thread_url = plugins_url( 'admin/vendor/zetajs/converterThread.js', DOCUMENTATE_PLUGIN_FILE );
 
+// Service Worker URL for Cross-Origin Isolation (iframe mode).
+$coi_sw_url = plugins_url( 'admin/js/coi-serviceworker.js', DOCUMENTATE_PLUGIN_FILE );
+
 ?>
 <!DOCTYPE html>
 <html>
 <head>
 	<meta charset="utf-8">
 	<title><?php esc_html_e( 'Documentate Converter', 'documentate' ); ?></title>
+	<?php if ( $is_iframe_mode ) : ?>
+	<!-- Service Worker for Cross-Origin Isolation in iframe mode.
+		 Must load before anything else to intercept requests and add COOP/COEP headers.
+		 Cannot use wp_enqueue_script() as this must execute synchronously before page load. -->
+	<?php // phpcs:ignore WordPress.WP.EnqueuedResources.NonEnqueuedScript -- Service Worker must load first. ?>
+	<script src="<?php echo esc_url( $coi_sw_url ); ?>"></script>
+	<?php endif; ?>
 	<style>
 		body {
 			margin: 0;
@@ -98,24 +113,50 @@
 			ajaxUrl: <?php echo wp_json_encode( admin_url( 'admin-ajax.php' ) ); ?>,
 			helperUrl: <?php echo wp_json_encode( $helper_url ); ?>,
 			threadUrl: <?php echo wp_json_encode( $thread_url ); ?>,
-			useChannel: <?php echo $use_channel ? 'true' : 'false'; ?>
+			useChannel: <?php echo $use_channel ? 'true' : 'false'; ?>,
+			// Iframe mode parameters (for WordPress Playground).
+			isIframeMode: <?php echo $is_iframe_mode ? 'true' : 'false'; ?>,
+			parentOrigin: <?php echo wp_json_encode( $parent_origin ); ?> || '*',
+			requestId: <?php echo wp_json_encode( $request_id ); ?> || Date.now().toString()
 		};
 
-		// BroadcastChannel for sending results to opener (when useChannel is true)
+		// Detect if we're in an iframe
+		const isInIframe = window.parent !== window;
+
+		// BroadcastChannel for sending results to opener (when useChannel is true, popup mode)
 		const channel = conversionConfig.useChannel ? new BroadcastChannel('documentate_converter') : null;
 
-		// Helper to send progress/results via channel
-		function sendToChannel(status, data, error) {
-			if (channel) {
-				channel.postMessage({
-					type: 'conversion_result',
-					status,
-					data,
-					error
-				});
+		/**
+		 * Send progress/results to parent window.
+		 * Uses postMessage for iframe mode, BroadcastChannel for popup mode.
+		 *
+		 * @param {string} status - 'progress', 'success', 'preview_ready', or 'error'
+		 * @param {Object} data - Data to send
+		 * @param {string} error - Error message (if status is 'error')
+		 */
+		function sendResult(status, data, error) {
+			const message = {
+				type: 'conversion_result',
+				status,
+				data,
+				error,
+				requestId: conversionConfig.requestId
+			};
+
+			if (isInIframe && conversionConfig.isIframeMode) {
+				// Iframe mode: use postMessage to parent
+				window.parent.postMessage(message, conversionConfig.parentOrigin);
+			} else if (channel) {
+				// Popup mode: use BroadcastChannel
+				channel.postMessage(message);
 			}
 		}
 
+		// Legacy alias for compatibility
+		function sendToChannel(status, data, error) {
+			sendResult(status, data, error);
+		}
+
 		// Debug info
 		console.log('Documentate: crossOriginIsolated =', window.crossOriginIsolated);
 		console.log('Documentate: SharedArrayBuffer =', typeof SharedArrayBuffer !== 'undefined');
@@ -268,7 +309,36 @@ function updateStatus(title, message, isError = false, isSuccess = false) {
 				const blob = new Blob([result.outputData], { type: mimeTypes[result.outputFormat] || 'application/octet-stream' });
 				const blobUrl = URL.createObjectURL(blob);
 
-				if (conversionConfig.useChannel) {
+				// Handle result based on mode: iframe vs popup
+				if (isInIframe && conversionConfig.isIframeMode) {
+					// IFRAME MODE: Always send data to parent via postMessage
+					// Parent will handle display/download
+
+					if (conversionConfig.outputAction === 'preview' && result.outputFormat === 'pdf') {
+						// For preview: send ArrayBuffer to parent, it will open in new window
+						sendResult('preview_ready', {
+							outputData: result.outputData,
+							outputFormat: result.outputFormat,
+							mimeType: mimeTypes[result.outputFormat] || 'application/octet-stream'
+						});
+					} else {
+						// For download: send ArrayBuffer to parent
+						sendResult('success', {
+							outputData: result.outputData,
+							outputFormat: result.outputFormat,
+							mimeType: mimeTypes[result.outputFormat] || 'application/octet-stream'
+						});
+					}
+
+					updateStatus(
+						<?php echo wp_json_encode( __( 'Completed!', 'documentate' ) ); ?>,
+						<?php echo wp_json_encode( __( 'Document sent to parent.', 'documentate' ) ); ?>,
+						false,
+						true
+					);
+
+				} else if (conversionConfig.useChannel) {
+					// POPUP MODE with BroadcastChannel
 					if (conversionConfig.outputAction === 'preview' && result.outputFormat === 'pdf') {
 						// For preview: reuse this popup window to show the PDF
 						// Notify opener that we're done (so it hides the loading modal)
@@ -331,15 +401,18 @@ function updateStatus(title, message, isError = false, isSuccess = false) {
 
 			} catch (error) {
 				console.error('Documentate conversion error:', error);
+				const errorMessage = error.message || <?php echo wp_json_encode( __( 'Conversion error.', 'documentate' ) ); ?>;
 
-				if (conversionConfig.useChannel) {
-					// Send error to opener via channel
-					sendToChannel('error', null, error.message || <?php echo wp_json_encode( __( 'Conversion error.', 'documentate' ) ); ?>);
+				// Send error to parent (works for both iframe and popup modes)
+				if (isInIframe && conversionConfig.isIframeMode) {
+					sendResult('error', null, errorMessage);
+				} else if (conversionConfig.useChannel) {
+					sendToChannel('error', null, errorMessage);
 				}
 
 				updateStatus(
 					<?php echo wp_json_encode( __( 'Error', 'documentate' ) ); ?>,
-					error.message || <?php echo wp_json_encode( __( 'Conversion error.', 'documentate' ) ); ?>,
+					errorMessage,
 					true
 				);
 			}
diff --git a/admin/js/coi-serviceworker.js b/admin/js/coi-serviceworker.js
new file mode 100644
index 0000000..36cb143
--- /dev/null
+++ b/admin/js/coi-serviceworker.js
@@ -0,0 +1,137 @@
+/*! coi-serviceworker v0.1.7 - Guido Zuidhof, licensed under MIT */
+/*
+ * Adapted for Documentate WordPress Plugin.
+ *
+ * This Service Worker enables Cross-Origin Isolation for environments
+ * where server headers cannot be configured (like WordPress Playground).
+ *
+ * It intercepts all fetch requests and adds the necessary COOP/COEP headers
+ * to enable SharedArrayBuffer support required by ZetaJS/LibreOffice WASM.
+ */
+
+let coepCredentialless = false;
+if (typeof window === 'undefined') {
+    self.addEventListener("install", () => self.skipWaiting());
+    self.addEventListener("activate", (e) => e.waitUntil(self.clients.claim()));
+
+    self.addEventListener("message", (ev) => {
+        if (!ev.data) {
+            return;
+        } else if (ev.data.type === "deregister") {
+            self.registration
+                .unregister()
+                .then(() => {
+                    return self.clients.matchAll();
+                })
+                .then((clients) => {
+                    clients.forEach((client) => client.navigate(client.url));
+                });
+        } else if (ev.data.type === "coepCredentialless") {
+            coepCredentialless = ev.data.value;
+        }
+    });
+
+    self.addEventListener("fetch", function (event) {
+        const r = event.request;
+        if (r.cache === "only-if-cached" && r.mode !== "same-origin") {
+            return;
+        }
+
+        const request =
+            coepCredentialless && r.mode === "no-cors"
+                ? new Request(r, {
+                    credentials: "omit",
+                })
+                : r;
+
+        event.respondWith(
+            fetch(request)
+                .then((response) => {
+                    if (response.status === 0) {
+                        return response;
+                    }
+
+                    const newHeaders = new Headers(response.headers);
+                    newHeaders.set("Cross-Origin-Embedder-Policy",
+                        coepCredentialless ? "credentialless" : "require-corp"
+                    );
+                    newHeaders.set("Cross-Origin-Opener-Policy", "same-origin");
+                    newHeaders.set("Cross-Origin-Resource-Policy", "cross-origin");
+
+                    return new Response(response.body, {
+                        status: response.status,
+                        statusText: response.statusText,
+                        headers: newHeaders,
+                    });
+                })
+                .catch((e) => console.error(e))
+        );
+    });
+
+} else {
+    (() => {
+        const reloadedBySelf = window.sessionStorage.getItem("coiReloadedBySelf");
+        window.sessionStorage.removeItem("coiReloadedBySelf");
+        const coepDegrading = (reloadedBySelf === "coepDegrade");
+
+        // You can customize the behavior of this script by setting coi configuration
+        // on the global scope before loading.
+        const coi = {
+            shouldRegister: () => !reloadedBySelf,
+            shouldDeregister: () => false,
+            coepCredentialless: () => true,
+            coepDegrade: () => true,
+            doReload: () => {
+                window.sessionStorage.setItem("coiReloadedBySelf",
+                    coepDegrading ? "coepDegrade" : "true");
+                window.location.reload();
+            },
+            quiet: false,
+            ...window.coi
+        };
+
+        const n = navigator;
+
+        if (coi.shouldDeregister()) {
+            n.serviceWorker &&
+                n.serviceWorker.controller &&
+                n.serviceWorker.controller.postMessage({ type: "deregister" });
+        }
+
+        // If we're already cross-origin isolated, no need for the service worker
+        if (window.crossOriginIsolated) {
+            !coi.quiet && console.log("Documentate COI: already cross-origin isolated");
+            return;
+        }
+
+        if (!coi.shouldRegister()) {
+            !coi.quiet && console.log("Documentate COI: will not register (already reloaded)");
+            return;
+        }
+
+        if (!n.serviceWorker) {
+            !coi.quiet && console.error("Documentate COI: ServiceWorker API not available");
+            return;
+        }
+
+        n.serviceWorker.register(window.document.currentScript.src).then(
+            (registration) => {
+                !coi.quiet && console.log("Documentate COI: Service Worker registered", registration.scope);
+
+                registration.addEventListener("updatefound", () => {
+                    !coi.quiet && console.log("Documentate COI: update found, reloading page");
+                    coi.doReload();
+                });
+
+                // If the service worker is already active, reload immediately
+                if (registration.active && !n.serviceWorker.controller) {
+                    !coi.quiet && console.log("Documentate COI: active, reloading page");
+                    coi.doReload();
+                }
+            },
+            (err) => {
+                !coi.quiet && console.error("Documentate COI: registration failed", err);
+            }
+        );
+    })();
+}
diff --git a/admin/js/documentate-actions.js b/admin/js/documentate-actions.js
index 11d299d..096d6f0 100644
--- a/admin/js/documentate-actions.js
+++ b/admin/js/documentate-actions.js
@@ -19,6 +19,7 @@
 	let $modal = null;
 	let converterChannel = null;
 	let converterPopup = null;
+	let converterIframe = null;
 	let pendingConversion = null;
 
 	/**
@@ -128,6 +129,46 @@
 		}
 	}
 
+	/**
+	 * Detect if running in WordPress Playground.
+	 *
+	 * @return {boolean} True if in Playground environment.
+	 */
+	function isPlayground() {
+		const url = window.location.href;
+		// Check URL patterns
+		if (url.includes('playground.wordpress.net')) return true;
+		// Check for Playground global
+		if (typeof window.WORDPRESS_PLAYGROUND !== 'undefined') return true;
+		// Check for Playground meta tag
+		if (document.querySelector('meta[name="wordpress-playground"]')) return true;
+		// Check config flag set by PHP
+		if (config.isPlayground) return true;
+		return false;
+	}
+
+	/**
+	 * Determine if we should use iframe mode instead of popup.
+	 * Iframe mode is used when popups are blocked (like in WordPress Playground).
+	 *
+	 * @return {boolean} True if iframe mode should be used.
+	 */
+	function shouldUseIframe() {
+		return config.useIframe || isPlayground();
+	}
+
+	/**
+	 * Determine if we should use external converter service.
+	 * In WordPress Playground, we can't register our own Service Worker
+	 * because Playground has its own SW that intercepts all requests.
+	 * The external service (erseco.github.io) has proper COOP/COEP headers.
+	 *
+	 * @return {boolean} True if external converter should be used.
+	 */
+	function shouldUseExternalConverter() {
+		return isPlayground() && config.externalConverterUrl;
+	}
+
 	/**
 	 * Initialize BroadcastChannel for receiving converter results.
 	 * This allows the COOP-isolated iframe to send results back to us.
@@ -178,6 +219,96 @@
 		converterPopup = null;
 	}
 
+	/**
+	 * Cleanup the converter iframe.
+	 */
+	function cleanupConverterIframe() {
+		if (converterIframe) {
+			converterIframe.remove();
+			converterIframe = null;
+		}
+	}
+
+	/**
+	 * Initialize postMessage listener for iframe results.
+	 * This handles messages from the converter iframe.
+	 */
+	function initIframeMessageListener() {
+		window.addEventListener('message', function (event) {
+			// Ignore messages not from our iframe
+			if (!converterIframe || !converterIframe.contentWindow) {
+				return;
+			}
+
+			// Security: Only accept messages from our iframe
+			if (event.source !== converterIframe.contentWindow) {
+				return;
+			}
+
+			const { type, status, data, error } = event.data;
+
+			if (type !== 'conversion_result') {
+				return;
+			}
+
+			console.log('Documentate: Received iframe message:', status, data);
+
+			if (status === 'success' && pendingConversion) {
+				handleIframeConversionSuccess(data, pendingConversion.action, pendingConversion.format);
+				pendingConversion = null;
+				cleanupConverterIframe();
+			} else if (status === 'preview_ready' && pendingConversion) {
+				handleIframeConversionSuccess(data, 'preview', data.outputFormat);
+				pendingConversion = null;
+				cleanupConverterIframe();
+			} else if (status === 'error') {
+				showError(error || strings.errorGeneric || 'Conversion error.');
+				pendingConversion = null;
+				cleanupConverterIframe();
+			} else if (status === 'progress') {
+				// Update modal with progress message
+				if (data && data.message) {
+					updateModal(data.title || null, data.message);
+				}
+			}
+		});
+	}
+
+	/**
+	 * Handle successful conversion result from iframe.
+	 *
+	 * @param {Object} data   Result data with outputData (ArrayBuffer) and outputFormat.
+	 * @param {string} action Action type (preview, download).
+	 * @param {string} format Target format.
+	 */
+	function handleIframeConversionSuccess(data, action, format) {
+		const mimeType = data.mimeType || 'application/octet-stream';
+
+		// Create blob from ArrayBuffer
+		const blob = new Blob([data.outputData], { type: mimeType });
+		const blobUrl = URL.createObjectURL(blob);
+
+		if (action === 'preview' && (data.outputFormat === 'pdf' || format === 'pdf')) {
+			// Open PDF preview in new window/tab
+			window.open(blobUrl, '_blank');
+		} else {
+			// Trigger download
+			const a = document.createElement('a');
+			a.href = blobUrl;
+			a.download = 'documento.' + (data.outputFormat || format || 'pdf');
+			document.body.appendChild(a);
+			a.click();
+			document.body.removeChild(a);
+
+			// Cleanup blob URL after a delay
+			setTimeout(function () {
+				URL.revokeObjectURL(blobUrl);
+			}, 1000);
+		}
+
+		hideModal();
+	}
+
 	/**
 	 * Handle successful conversion result from popup.
 	 *
@@ -219,60 +350,237 @@
 	}
 
 	/**
-	 * Handle WASM mode conversion via popup with BroadcastChannel.
-	 * The popup does the conversion and sends results back via BroadcastChannel.
+	 * Handle conversion using external converter service via window.opener + postMessage.
+	 * Opens converter in new tab which captures document via postMessage BEFORE COI reload.
+	 *
+	 * Flow:
+	 * 1. Generate source document via AJAX
+	 * 2. Download the generated document
+	 * 3. Open converter with ?receive=opener (tells it to wait for data)
+	 * 4. Converter's early capture script receives document BEFORE Service Worker reload
+	 * 5. Document is stored in sessionStorage, survives COI reload
+	 * 6. After reload with COI enabled, converter processes stored document
+	 *
+	 * @param {jQuery} $btn         The button element.
+	 * @param {string} action       Action type (preview, download).
+	 * @param {string} targetFormat Target format.
+	 * @param {string} sourceFormat Source format.
+	 */
+	async function handleExternalConverterConversion($btn, action, targetFormat, sourceFormat) {
+		let converterWindow = null;
+
+		try {
+			// Step 1: Generate source document via AJAX
+			updateModal(
+				strings.generating || 'Generating document...',
+				strings.wait || 'Please wait...'
+			);
+
+			const formData = new FormData();
+			formData.append('action', 'documentate_generate_document');
+			formData.append('post_id', config.postId);
+			formData.append('format', sourceFormat);
+			formData.append('output', 'download');
+			formData.append('_wpnonce', config.nonce);
+
+			const ajaxResponse = await fetch(config.ajaxUrl, {
+				method: 'POST',
+				body: formData,
+				credentials: 'same-origin'
+			});
+			const ajaxData = await ajaxResponse.json();
+
+			if (!ajaxData.success || !ajaxData.data?.url) {
+				throw new Error(ajaxData.data?.message || 'Failed to generate source document');
+			}
+
+			// Step 2: Fetch the generated document
+			updateModal(
+				strings.loadingWasm || 'Loading converter...',
+				'Downloading document...'
+			);
+
+			const docResponse = await fetch(ajaxData.data.url, { credentials: 'same-origin' });
+			if (!docResponse.ok) {
+				throw new Error('Failed to download source document');
+			}
+			const docBuffer = await docResponse.arrayBuffer();
+
+			// Step 3: Open converter in new tab with receive=opener mode
+			updateModal(
+				strings.loadingWasm || 'Opening converter...',
+				'A new tab will open. Sending document...'
+			);
+
+			// Build URL with opener mode parameters
+			const queryParams = new URLSearchParams({
+				receive: 'opener',
+				format: targetFormat,
+				name: 'documento.' + sourceFormat,
+				fullscreen: action === 'preview' ? 'true' : 'false',
+				download: action !== 'preview' ? 'true' : 'false'
+			});
+
+			const converterUrl = config.externalConverterUrl + '?' + queryParams.toString();
+
+			// Open the converter window - the page will signal when ready
+			converterWindow = window.open(converterUrl, 'documentate_converter');
+
+			if (!converterWindow) {
+				throw new Error('Could not open converter window. Please allow popups for this site.');
+			}
+
+			// Step 4: Wait for converter to signal ready (pre-COI), then send document
+			const documentSent = await new Promise((resolve, reject) => {
+				const timeout = setTimeout(() => {
+					window.removeEventListener('message', readyHandler);
+					reject(new Error('Converter did not respond in time. Please try again.'));
+				}, 30000); // 30 seconds timeout for initial ready signal
+
+				const readyHandler = (event) => {
+					if (!event.data || !event.data.type) return;
+
+					if (event.data.type === 'converterReady') {
+						console.log('Documentate: Converter ready (preCOI:', event.data.preCOI, '), sending document...');
+
+						// Send the document immediately
+						if (converterWindow && !converterWindow.closed) {
+							converterWindow.postMessage({
+								type: 'convertDocument',
+								buffer: docBuffer,
+								name: 'documento.' + sourceFormat,
+								format: targetFormat,
+								fullscreen: action === 'preview',
+								download: action !== 'preview'
+							}, '*');
+						}
+
+						// Don't resolve yet - wait for documentReceived confirmation
+					} else if (event.data.type === 'documentReceived') {
+						clearTimeout(timeout);
+						window.removeEventListener('message', readyHandler);
+						console.log('Documentate: Document received by converter');
+						resolve(true);
+					}
+				};
+
+				window.addEventListener('message', readyHandler);
+			});
+
+			if (documentSent) {
+				updateModal(
+					strings.convertingBrowser || 'Converting...',
+					'Document sent. Conversion will complete in the new tab.'
+				);
+			}
+
+			// Hide modal after a short delay - conversion happens in the new tab
+			setTimeout(function() {
+				hideModal();
+			}, 2000);
+
+		} catch (error) {
+			console.error('Documentate external conversion error:', error);
+			showError(error.message || strings.errorGeneric || 'Conversion error.');
+			pendingConversion = null;
+		}
+	}
+
+	/**
+	 * Handle WASM mode conversion via popup or iframe.
 	 * The modal stays visible in this window showing progress.
 	 *
-	 * Note: We use a popup instead of iframe because SharedArrayBuffer requires
-	 * cross-origin isolation (COOP/COEP headers), which only works in top-level
-	 * browsing contexts (popups), not in iframes embedded in non-isolated pages.
+	 * Uses external converter in WordPress Playground (where Service Workers can't be registered),
+	 * iframe mode in other environments where popups are blocked,
+	 * and popup mode in regular WordPress installations.
 	 *
-	 * @param {jQuery} $btn The button element.
-	 * @param {string} action Action type (preview, download).
+	 * @param {jQuery} $btn         The button element.
+	 * @param {string} action       Action type (preview, download).
 	 * @param {string} targetFormat Target format.
 	 * @param {string} sourceFormat Source format.
 	 */
 	function handleCdnConversion($btn, action, targetFormat, sourceFormat) {
-		// Initialize channel if needed
-		initConverterChannel();
-
 		// Store pending conversion info
 		pendingConversion = {
 			action: action,
 			format: targetFormat
 		};
 
-		// Build URL with conversion parameters
-		const params = new URLSearchParams({
-			post_id: config.postId,
-			format: targetFormat,
-			source: sourceFormat,
-			output: action,
-			_wpnonce: config.nonce,
-			use_channel: '1' // Tell popup to use BroadcastChannel
-		});
+		if (shouldUseExternalConverter()) {
+			// EXTERNAL CONVERTER MODE: For WordPress Playground
+			// Playground has its own Service Worker that prevents us from registering ours.
+			// We use the external converter service which has proper COOP/COEP headers.
+			console.log('Documentate: Using external converter for Playground');
+			handleExternalConverterConversion($btn, action, targetFormat, sourceFormat);
+
+		} else if (shouldUseIframe()) {
+			// IFRAME MODE: For environments where popups are blocked but SW works
+			// The iframe uses a Service Worker to enable cross-origin isolation
+			console.log('Documentate: Using iframe mode for conversion');
+
+			// Cleanup any existing iframe
+			cleanupConverterIframe();
+
+			// Build URL with iframe mode parameters
+			const params = new URLSearchParams({
+				mode: 'iframe',
+				post_id: config.postId,
+				format: targetFormat,
+				source: sourceFormat,
+				output: action,
+				_wpnonce: config.nonce,
+				parent_origin: window.location.origin,
+				request_id: Date.now().toString()
+			});
+
+			// Create hidden iframe for conversion
+			converterIframe = document.createElement('iframe');
+			converterIframe.id = 'documentate-converter-iframe';
+			converterIframe.style.cssText = 'position:fixed;width:1px;height:1px;left:-9999px;top:-9999px;border:none;';
+			converterIframe.src = config.converterUrl + '&' + params.toString();
+
+			document.body.appendChild(converterIframe);
+
+		} else {
+			// POPUP MODE: For regular WordPress installations
+			// The popup receives COOP/COEP headers from PHP
+			console.log('Documentate: Using popup mode for conversion');
 
-		// Open minimal popup for conversion
-		// Position at bottom-right corner with minimal size to reduce visibility
-		const width = 1;
-		const height = 1;
-		const left = window.screen.availWidth - 1;
-		const top = window.screen.availHeight - 1;
-
-		// converterUrl already has ?action=documentate_converter, so append with &
-		converterPopup = window.open(
-			config.converterUrl + '&' + params.toString(),
-			'documentate_converter',
-			`width=${width},height=${height},left=${left},top=${top},menubar=no,toolbar=no,location=no,status=no,resizable=no,scrollbars=no`
-		);
-
-		// Immediately refocus the main window to minimize popup disruption
-		if (converterPopup) {
-			window.focus();
+			// Initialize BroadcastChannel for popup communication
+			initConverterChannel();
+
+			// Build URL with popup mode parameters
+			const params = new URLSearchParams({
+				post_id: config.postId,
+				format: targetFormat,
+				source: sourceFormat,
+				output: action,
+				_wpnonce: config.nonce,
+				use_channel: '1' // Tell popup to use BroadcastChannel
+			});
+
+			// Open minimal popup for conversion
+			// Position at bottom-right corner with minimal size to reduce visibility
+			const width = 1;
+			const height = 1;
+			const left = window.screen.availWidth - 1;
+			const top = window.screen.availHeight - 1;
+
+			// converterUrl already has ?action=documentate_converter, so append with &
+			converterPopup = window.open(
+				config.converterUrl + '&' + params.toString(),
+				'documentate_converter',
+				`width=${width},height=${height},left=${left},top=${top},menubar=no,toolbar=no,location=no,status=no,resizable=no,scrollbars=no`
+			);
+
+			// Immediately refocus the main window to minimize popup disruption
+			if (converterPopup) {
+				window.focus();
+			}
 		}
 
 		// Keep modal visible - it shows progress
-		// The popup will send progress updates via BroadcastChannel
+		// Results will come via postMessage (iframe) or BroadcastChannel (popup)
 	}
 
 	/**
@@ -352,8 +660,21 @@
 	 * Initialize.
 	 */
 	function init() {
+		// Initialize postMessage listener for iframe mode (local converter)
+		initIframeMessageListener();
+
 		// Bind click handlers to action buttons
 		$(document).on('click', '[data-documentate-action]', handleActionClick);
+
+		// Log mode for debugging
+		if (shouldUseExternalConverter()) {
+			console.log('Documentate: External converter will be used for WASM conversions (Playground mode)');
+			console.log('Documentate: Documents will be POSTed to', config.externalConverterUrl);
+		} else if (shouldUseIframe()) {
+			console.log('Documentate: Iframe mode will be used for WASM conversions');
+		} else {
+			console.log('Documentate: Popup mode will be used for WASM conversions');
+		}
 	}
 
 	$(init);
diff --git a/includes/class-documentate-admin-helper.php b/includes/class-documentate-admin-helper.php
index d6f7d7c..50f4543 100644
--- a/includes/class-documentate-admin-helper.php
+++ b/includes/class-documentate-admin-helper.php
@@ -817,6 +817,19 @@ public function enqueue_actions_metabox_assets( $hook_suffix ) {
 		if ( $zetajs_cdn_available ) {
 			$config['cdnMode']      = true;
 			$config['converterUrl'] = admin_url( 'admin-post.php?action=documentate_converter' );
+
+			// Detect WordPress Playground environment.
+			// In Playground, we can't register Service Workers, so we use external converter.
+			require_once plugin_dir_path( __DIR__ ) . 'includes/class-documentate-collabora-converter.php';
+			$is_playground          = Documentate_Collabora_Converter::is_playground();
+			$config['isPlayground'] = $is_playground;
+			$config['useIframe']    = $is_playground;
+
+			// External converter URL for Playground (where Service Workers don't work).
+			// This service has proper COOP/COEP headers for SharedArrayBuffer support.
+			if ( $is_playground ) {
+				$config['externalConverterUrl'] = 'https://erseco.github.io/document-converter/';
+			}
 		}
 
 		wp_localize_script( 'documentate-actions', 'documentateActionsConfig', $config );
diff --git a/languages/documentate-es_ES.po b/languages/documentate-es_ES.po
index 481f94a..73ee796 100644
--- a/languages/documentate-es_ES.po
+++ b/languages/documentate-es_ES.po
@@ -800,3 +800,6 @@ msgstr "¡Datos de ejemplo creados correctamente!"
 
 msgid "Generated file not found."
 msgstr "Fichero generado no encontrado."
+
+msgid "Document sent to parent."
+msgstr "Documento enviado al origen"
diff --git a/languages/documentate.pot b/languages/documentate.pot
index 2357871..246dae8 100644
--- a/languages/documentate.pot
+++ b/languages/documentate.pot
@@ -357,6 +357,9 @@ msgstr ""
 msgid "Completed!"
 msgstr ""
 
+msgid "Document sent to parent."
+msgstr ""
+
 msgid "Document converted."
 msgstr ""
 
