diff --git a/configure/package.json b/configure/package.json
index 854d0d6d3..928106a84 100644
--- a/configure/package.json
+++ b/configure/package.json
@@ -1,6 +1,6 @@
 {
   "name": "configure",
-  "version": "4.2.13-20260701",
+  "version": "4.2.14-20260702",
   "homepage": "./configure/build",
   "private": true,
   "dependencies": {
diff --git a/package.json b/package.json
index a3fd07e42..219d438e1 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "mmgis",
-  "version": "4.2.13-20260701",
+  "version": "4.2.14-20260702",
   "description": "A web-based mapping and localization solution for science operation on planetary missions.",
   "homepage": "build",
   "repository": {
diff --git a/src/essence/Ancillary/ContextMenu.js b/src/essence/Ancillary/ContextMenu.js
index c4e802ec0..a58ea0476 100644
--- a/src/essence/Ancillary/ContextMenu.js
+++ b/src/essence/Ancillary/ContextMenu.js
@@ -97,22 +97,28 @@ function showContextMenuMap(e) {
     $('#contextMenuMapCopyCoords').on('click', function () {
         F_.copyToClipboard(
             JSON.stringify(Coordinates.getAllCoordinates(), null, 2)
-        )
-        $('#contextMenuMapCopyCoords').text('Copied!')
-        setTimeout(function () {
-            $('#contextMenuMapCopyCoords').text('Copy Coordinates')
-        }, 2000)
+        ).then((copied) => {
+            if (!copied) return
+            $('#contextMenuMapCopyCoords').text('Copied!')
+            setTimeout(function () {
+                $('#contextMenuMapCopyCoords').text('Copy Coordinates')
+            }, 2000)
+        })
     })
 
     $('#contextMenuCopyable').on('click', function () {
         const that = this
         const key = $(that).attr('key')
         const copyable = L_._toolCopyables[key]
-        F_.copyToClipboard(JSON.stringify(copyable.copyable, null, 2))
-        $(that).text('Copied!')
-        setTimeout(function () {
-            $(that).text(copyable.title)
-        }, 2000)
+        F_.copyToClipboard(JSON.stringify(copyable.copyable, null, 2)).then(
+            (copied) => {
+                if (!copied) return
+                $(that).text('Copied!')
+                setTimeout(function () {
+                    $(that).text(copyable.title)
+                }, 2000)
+            }
+        )
     })
 
     contextMenuActionsFull.forEach((c) => {
diff --git a/src/essence/Ancillary/QueryURL.js b/src/essence/Ancillary/QueryURL.js
index 39aea2df0..288478dec 100644
--- a/src/essence/Ancillary/QueryURL.js
+++ b/src/essence/Ancillary/QueryURL.js
@@ -4,6 +4,7 @@ import F_ from '../Basics/Formulae_/Formulae_'
 import L_ from '../Basics/Layers_/Layers_'
 import T_ from '../Basics/ToolController_/ToolController_'
 import calls from '../../pre/calls'
+import { isStaticBuild } from '../../pre/capabilities'
 import TimeControl from '../Basics/TimeControl_/TimeControl'
 import TimeUI from '../Basics/TimeControl_/TimeUI'
 
@@ -50,7 +51,10 @@ var QueryURL = {
             L_.FUTURES.mapView = [
                 parseFloat(urlMapLat),
                 parseFloat(urlMapLon),
-                urlMapZoom !== false ? parseInt(urlMapZoom) : null,
+                // parseFloat, not parseInt: the modern map zooms fractionally and
+                // truncation visibly changes the restored view (classic Leaflet
+                // zooms are integers either way).
+                urlMapZoom !== false ? parseFloat(urlMapZoom) : null,
             ]
         }
 
@@ -277,8 +281,10 @@ var QueryURL = {
     tools
       "tools=camp$1.3.4,"
     */
+    // Builds and returns the full, self-contained view URL synchronously. This
+    // is the canonical share-link method (exposed publicly via
+    // mmgisAPI.writeCoordinateURL). It makes no backend call.
     writeCoordinateURL: function (
-        shortenURL = true,
         mapLon,
         mapLat,
         mapZoom,
@@ -288,12 +294,6 @@ var QueryURL = {
     ) {
         L_.Viewer_.getLocation()
 
-        var callback
-        if (typeof mapLon === 'function') {
-            callback = mapLon
-            mapLon = undefined
-        }
-
         //Defaults
         if (mapLon == undefined) mapLon = L_.Map_.map.getCenter().lng
         if (mapLat == undefined) mapLat = L_.Map_.map.getCenter().lat
@@ -358,7 +358,13 @@ var QueryURL = {
         }
 
         //panePercents
-        var pP = L_.UserInterface_.getPanelPercents()
+        // getPanelPercents only exists on the classic/mobile UI controllers; the
+        // modern layout has no such method, so fall back to a map-only split.
+        var pP =
+            L_.UserInterface_ &&
+            typeof L_.UserInterface_.getPanelPercents === 'function'
+                ? L_.UserInterface_.getPanelPercents()
+                : { viewer: 0, map: 100, globe: 0 }
         var panePercents = pP.viewer + ',' + pP.map + ',' + pP.globe
         urlAppendage += '&panePercents=' + panePercents
 
@@ -427,29 +433,34 @@ var QueryURL = {
 
         var url = encodeURI(urlAppendage)
 
-        if (shortenURL) {
-            calls.api(
-                'shortener_shorten',
-                {
-                    url: url,
-                },
-                function (s) {
-                    //Set and update the short url
-                    L_.url =
-                        window.location.href.split('?')[0] + '?s=' + s.body.url
-                    window.history.replaceState('', '', L_.url)
-                    if (typeof callback === 'function') callback()
-                },
-                function (e) {
-                    //Set and update the full url
-                    L_.url = window.location.href.split('?')[0] + url
-                    window.history.replaceState('', '', L_.url)
-                    if (typeof callback === 'function') callback()
-                }
-            )
+        return window.location.href.split('?')[0] + url
+    },
+    getShareURL: function (callback) {
+        var fullUrl = this.writeCoordinateURL()
+
+        if (isStaticBuild()) {
+            if (typeof callback === 'function') callback(fullUrl)
+            return
         }
 
-        return window.location.href.split('?')[0] + url
+        var baseUrl = window.location.href.split('?')[0]
+        var urlAppendage = fullUrl.startsWith(baseUrl)
+            ? fullUrl.substring(baseUrl.length)
+            : fullUrl.substring(fullUrl.indexOf('?'))
+
+        calls.api(
+            'shortener_shorten',
+            {
+                url: urlAppendage,
+            },
+            function (s) {
+                var shortUrl = baseUrl + '?s=' + s.body.url
+                if (typeof callback === 'function') callback(shortUrl)
+            },
+            function () {
+                if (typeof callback === 'function') callback(fullUrl)
+            }
+        )
     },
     writeSearchURL: function (searchStrs, searchFile) {
         return //!!!!!!!!!!!!!!!!
diff --git a/src/essence/Basics/Formulae_/Formulae_.js b/src/essence/Basics/Formulae_/Formulae_.js
index 0bcf8e5d1..2a0337ebd 100644
--- a/src/essence/Basics/Formulae_/Formulae_.js
+++ b/src/essence/Basics/Formulae_/Formulae_.js
@@ -1803,18 +1803,18 @@ var Formulae_ = {
         downloadAnchorNode.click()
         downloadAnchorNode.remove()
     },
-    downloadCanvas(canvasId, name, callback) {
-        var link = document.createElement('a')
-        name = name ? name + '.png' : 'mmgis.png'
-        link.setAttribute('download', name)
-        document.getElementById(canvasId).toBlob(function (blob) {
-            var objUrl = URL.createObjectURL(blob)
-            link.setAttribute('href', objUrl)
-            document.body.appendChild(link)
-            link.click()
-            link.remove()
-            if (typeof callback === 'function') callback()
-        })
+    // Downloads a Blob as a file via a transient object URL. Don't convert
+    // via fetch(dataUrl): the shipped CSP's connect-src blocks the data: scheme.
+    downloadBlob(blob, filename) {
+        const url = URL.createObjectURL(blob)
+        const link = document.createElement('a')
+        link.setAttribute('download', filename)
+        link.setAttribute('href', url)
+        document.body.appendChild(link) // required for firefox
+        link.click()
+        link.remove()
+        // Deferred: an immediate revoke can abort the download.
+        setTimeout(() => URL.revokeObjectURL(url), 10000)
     },
     getMinMaxOfArray(arrayOfNumbers) {
         return {
@@ -2043,28 +2043,49 @@ var Formulae_ = {
         return arr1.filter((e) => arr2.indexOf(e) !== -1)
     },
     /**
-     * Copies input to user's clipboard
+     * Copies text to the user's clipboard. Resolves true on success, false on
+     * failure — never rejects. Tries the async Clipboard API first, falling
+     * back to a hidden textarea + execCommand('copy') when it is absent
+     * (insecure origins) OR when it rejects (e.g. an embedding iframe without
+     * allow="clipboard-write", or a call outside the user-gesture window).
      * @param {string} text - text to copy to clipboard
-     * @credit https://hackernoon.com/copying-text-to-clipboard-with-javascript-df4d4988697f
+     * @returns {Promise<boolean>}
      */
-    copyToClipboard(text) {
-        const el = document.createElement('textarea') // Create a <textarea> element
-        el.value = text // Set its value to the string that you want copied
-        el.setAttribute('readonly', '') // Make it readonly to be tamper-proof
+    async copyToClipboard(text) {
+        if (navigator.clipboard?.writeText) {
+            try {
+                await navigator.clipboard.writeText(text)
+                return true
+            } catch (err) {
+                // Fall through to the legacy path.
+            }
+        }
+        const el = document.createElement('textarea')
+        el.value = text
+        el.setAttribute('readonly', '')
         el.style.position = 'absolute'
-        el.style.left = '-9999px' // Move outside the screen to make it invisible
-        document.body.appendChild(el) // Append the <textarea> element to the HTML document
-        const selected =
-            document.getSelection().rangeCount > 0 // Check if there is any content selected previously
-                ? document.getSelection().getRangeAt(0) // Store selection if found
-                : false // Mark as false to know no selection existed before
-        el.select() // Select the <textarea> content
-        document.execCommand('copy') // Copy - only works as a result of a user action (e.g. click events)
-        document.body.removeChild(el) // Remove the <textarea> element
-        if (selected) {
-            // If a selection existed before copying
-            document.getSelection().removeAllRanges() // Unselect everything on the HTML document
-            document.getSelection().addRange(selected) // Restore the original selection
+        el.style.left = '-9999px'
+        // select() destroys the user's page selection; save and restore it.
+        const selection = document.getSelection()
+        const savedRange =
+            selection && selection.rangeCount > 0
+                ? selection.getRangeAt(0)
+                : null
+        document.body.appendChild(el)
+        try {
+            el.select()
+            const ok = document.execCommand('copy')
+            if (!ok) console.warn('copyToClipboard: copy command rejected')
+            return ok
+        } catch (err) {
+            console.warn('copyToClipboard failed:', err)
+            return false
+        } finally {
+            document.body.removeChild(el)
+            if (selection && savedRange) {
+                selection.removeAllRanges()
+                selection.addRange(savedRange)
+            }
         }
     },
     speedToMetersPerSeconds(speed, fromUnit) {
diff --git a/src/essence/Basics/MapEngines/Adapters/DeckGLAdapter.ts b/src/essence/Basics/MapEngines/Adapters/DeckGLAdapter.ts
index 3ba161004..5dc68bfa0 100644
--- a/src/essence/Basics/MapEngines/Adapters/DeckGLAdapter.ts
+++ b/src/essence/Basics/MapEngines/Adapters/DeckGLAdapter.ts
@@ -29,7 +29,7 @@ import { MapboxOverlay } from '@deck.gl/mapbox'
 import { Map as MaplibreGLMap } from 'maplibre-gl'
 import 'maplibre-gl/dist/maplibre-gl.css'
 
-import type { IMapEngine } from '../IMapEngine'
+import type { IMapEngine, MapScreenshotResult } from '../IMapEngine'
 import { MAP_ENGINE } from '../types/engine'
 import type { MapEngineType } from '../types/engine'
 import type { LatLng, LatLngLike, BoundsLike, PointLike } from '../types/geometry'
@@ -121,10 +121,45 @@ interface BasemapInstance {
     setMaxBounds(bounds: [[number, number], [number, number]] | null): unknown
     /** Register a map event listener. */
     on(type: string, handler: (...args: unknown[]) => void): unknown
+    /** Register a one-shot map event listener that auto-removes after firing once. */
+    once(type: string, handler: (...args: unknown[]) => void): unknown
     /** Remove a previously registered map event listener. */
     off(type: string, handler: (...args: unknown[]) => void): unknown
     /** Recalculate the map size from its container element. */
     resize(): void
+    /** Return the WebGL canvas element the base map renders into. */
+    getCanvas(): HTMLCanvasElement
+    /** Schedule a re-render on the next animation frame (mapbox-gl + maplibre-gl). */
+    triggerRepaint(): void
+}
+
+/**
+ * How long {@link DeckGLAdapter.captureScreenshot} waits for the basemap's
+ * `render` event before rejecting. Generous enough for a slow first frame,
+ * short enough that a dead map fails fast.
+ */
+const SCREENSHOT_RENDER_TIMEOUT_MS = 3000
+
+function canvasToPngScreenshot(canvas: HTMLCanvasElement): Promise<MapScreenshotResult> {
+    return new Promise((resolve, reject) => {
+        if (typeof canvas.toBlob !== 'function') {
+            reject(new Error('[DeckGLAdapter] captureScreenshot: canvas.toBlob is unavailable'))
+            return
+        }
+        canvas.toBlob((blob) => {
+            if (!blob) {
+                reject(new Error('[DeckGLAdapter] captureScreenshot: canvas.toBlob returned null'))
+                return
+            }
+            resolve({
+                blob,
+                mimeType: 'image/png',
+                extension: 'png',
+                width: canvas.width,
+                height: canvas.height,
+            })
+        }, 'image/png')
+    })
 }
 
 /**
@@ -364,6 +399,70 @@ export class DeckGLAdapter implements IMapEngine<Deck, Layer, PickingInfo> {
         return this._container
     }
 
+    /**
+     * Capture the current map view as a PNG Blob screenshot result.
+     *
+     * WebGL clears its drawing buffer once the browser presents a frame, so
+     * `canvas.toDataURL()` only returns pixels if the read happens before
+     * that clear. Rather than paying the per-frame cost of creating the GL
+     * context with `preserveDrawingBuffer: true`, we capture on demand:
+     * overlay mode reads the shared (interleaved) canvas inside a
+     * `once('render')` handler after `triggerRepaint()` — the render event
+     * fires before the browser presents/clears the buffer; standalone mode
+     * reads right after `deck.redraw(reason)`, which draws synchronously in
+     * deck.gl v9, so the buffer is still valid within the same task.
+     *
+     * Captures only the GL canvas: HTML overlays/markers added via
+     * {@link addOverlay} are separate DOM nodes and are not included.
+     */
+    captureScreenshot(): Promise<MapScreenshotResult> {
+        return new Promise<MapScreenshotResult>((resolve, reject) => {
+            try {
+                if (this._isOverlayMode && this._basemap) {
+                    const basemap = this._basemap
+                    const onRender = () => {
+                        clearTimeout(timeout)
+                        canvasToPngScreenshot(basemap.getCanvas()).then(
+                            resolve,
+                            reject
+                        )
+                    }
+                    const timeout = setTimeout(() => {
+                        // Unhook, or the listener stays armed to fire a wasted
+                        // capture on some later render (e.g. backgrounded tab).
+                        basemap.off('render', onRender)
+                        reject(
+                            new Error(
+                                '[DeckGLAdapter] captureScreenshot: timed out waiting for the basemap render event'
+                            )
+                        )
+                    }, SCREENSHOT_RENDER_TIMEOUT_MS)
+                    basemap.once('render', onRender)
+                    basemap.triggerRepaint()
+                    return
+                }
+
+                const deck = this._deck
+                if (!deck) {
+                    reject(new Error('[DeckGLAdapter] captureScreenshot: no active map to capture'))
+                    return
+                }
+                deck.redraw('screenshot')
+                const canvas = (deck as unknown as { getCanvas?: () => HTMLCanvasElement })
+                    .getCanvas?.()
+                if (!canvas) {
+                    reject(
+                        new Error('[DeckGLAdapter] captureScreenshot: deck canvas unavailable')
+                    )
+                    return
+                }
+                canvasToPngScreenshot(canvas).then(resolve, reject)
+            } catch (err) {
+                reject(err as Error)
+            }
+        })
+    }
+
     /**
      * Anchored HTML overlay. deck.gl renders to canvas and has no native
      * overlay system, so we own the DOM node directly: append to the
@@ -1039,6 +1138,9 @@ export class DeckGLAdapter implements IMapEngine<Deck, Layer, PickingInfo> {
     private _initStandaloneMode(): void {
         this._deck = new Deck({
             parent: this._container,
+            // No preserveDrawingBuffer needed: captureScreenshot() reads the
+            // canvas synchronously after deck.redraw(), before the browser
+            // presents (and clears) the drawing buffer.
             width: '100%',
             height: '100%',
             controller: true,
@@ -1107,6 +1209,9 @@ export class DeckGLAdapter implements IMapEngine<Deck, Layer, PickingInfo> {
             minZoom: this._minZoom,
             maxZoom: this._maxZoom,
             projection: 'mercator',
+            // No preserveDrawingBuffer needed: captureScreenshot() reads the
+            // canvas inside a once('render') handler, in the same frame the
+            // map draws — before the drawing buffer is presented and cleared.
         }
 
         if (basemap.provider === 'mapbox' && basemap.accessToken) {
diff --git a/src/essence/Basics/MapEngines/Adapters/LeafletAdapter.ts b/src/essence/Basics/MapEngines/Adapters/LeafletAdapter.ts
index 836aa0be1..81f038db8 100644
--- a/src/essence/Basics/MapEngines/Adapters/LeafletAdapter.ts
+++ b/src/essence/Basics/MapEngines/Adapters/LeafletAdapter.ts
@@ -7,7 +7,7 @@
  * 
  */
 
-import { IMapEngine } from '../IMapEngine'
+import { IMapEngine, MapScreenshotResult } from '../IMapEngine'
 import {
     LatLng,
     LatLngLike,
@@ -46,6 +46,7 @@ import {
 } from 'terra-draw'
 import { TerraDrawLeafletAdapter } from 'terra-draw-leaflet-adapter'
 import { extractVerticesFromGeometry } from './DrawingHelpers'
+import { getMapScreenshot } from './LeafletScreenshot'
 import {
     MapEventHandler,
     MapEventOptions,
@@ -331,6 +332,19 @@ export default class LeafletAdapter implements IMapEngine<any, any, any>, IMapEn
         return this._container!
     }
 
+    /**
+     * Capture the current Leaflet view as a PNG Blob result.
+     *
+     * Delegates to the shared {@link getMapScreenshot} helper, which performs
+     * the html2canvas rasterization plus the Leaflet-specific DOM prep
+     * (pane z-index normalization, SVG re-parenting, UI-chrome hide/restore).
+     * That logic is correct for Leaflet's DOM/SVG/tile rendering and is left
+     * unchanged here.
+     */
+    captureScreenshot(): Promise<MapScreenshotResult> {
+        return getMapScreenshot()
+    }
+
     // ========================================
     // VIEW CONTROL METHODS
     // ========================================
@@ -1254,4 +1268,3 @@ export default class LeafletAdapter implements IMapEngine<any, any, any>, IMapEn
         return null
     }
 }
-
diff --git a/src/essence/Basics/MapEngines/Adapters/LeafletCloneFixups.js b/src/essence/Basics/MapEngines/Adapters/LeafletCloneFixups.js
new file mode 100644
index 000000000..4eecfca3d
--- /dev/null
+++ b/src/essence/Basics/MapEngines/Adapters/LeafletCloneFixups.js
@@ -0,0 +1,52 @@
+/**
+ * Shared html2canvas clone fixups for Leaflet maps, used by the screenshot
+ * capture (LeafletScreenshot) and the Animation tool's offscreen frame capture
+ * (OffscreenMapManager); only the scoping selectors differ.
+ *
+ * - Leaflet positions zoom-animated overlay SVG containers with inline CSS
+ *   transforms. html2canvas can render those transformed SVGs shifted, so each
+ *   SVG is re-parented into a wrapper <div> that carries the transform.
+ * - Leaflet tile layers use inline z-index values on their containers. The
+ *   fixup reapplies the capture-time values so screenshot ordering matches the
+ *   map state at capture kickoff.
+ *
+ * Styles are snapshotted up front rather than read inside `onclone`, which
+ * fires asynchronously — after the caller may have restored the live styles.
+ */
+
+/** Reads the inline styles the fixups need from the live document. */
+export function snapshotLeafletPaneStyles({ svgSelector, tileSelector }) {
+    return {
+        svgSelector,
+        tileSelector,
+        svgStyles: Array.from(
+            document.body.querySelectorAll(svgSelector),
+            (el) => el.getAttribute('style')
+        ),
+        tileStyles: Array.from(
+            document.body.querySelectorAll(tileSelector),
+            (el) => el.getAttribute('style')
+        ),
+    }
+}
+
+/** Applies the fixups to an html2canvas clone (`e.body` from onclone). */
+export function applyLeafletCloneFixups(cloneBody, snapshot) {
+    const copySVG = cloneBody.querySelectorAll(snapshot.svgSelector)
+    copySVG.forEach((copyEle, i) => {
+        const attribute = snapshot.svgStyles[i]
+        const parentElement = copyEle.parentElement
+        parentElement.removeChild(copyEle)
+        const temp = document.createElement('div')
+        temp.appendChild(copyEle)
+        parentElement.appendChild(temp)
+        if (attribute != null) temp.setAttribute('style', attribute)
+        copyEle.removeAttribute('style')
+    })
+
+    const copyZ = cloneBody.querySelectorAll(snapshot.tileSelector)
+    copyZ.forEach((copyEle, i) => {
+        if (snapshot.tileStyles[i] != null)
+            copyEle.setAttribute('style', snapshot.tileStyles[i])
+    })
+}
diff --git a/src/essence/Basics/MapEngines/Adapters/LeafletScreenshot.js b/src/essence/Basics/MapEngines/Adapters/LeafletScreenshot.js
new file mode 100644
index 000000000..df40556d5
--- /dev/null
+++ b/src/essence/Basics/MapEngines/Adapters/LeafletScreenshot.js
@@ -0,0 +1,120 @@
+import jquery from 'jquery'
+import html2canvas from 'html2canvas'
+
+import {
+    snapshotLeafletPaneStyles,
+    applyLeafletCloneFixups,
+} from './LeafletCloneFixups'
+
+/**
+ * The Leaflet map engine's screenshot strategy: rasterizes the map container
+ * with html2canvas, temporarily hiding some UI (zoom controls, compass, scale
+ * factor, time UI) and normalizing the Leaflet pane z-indices for the shot.
+ *
+ * @returns {Promise<object>} Resolves to a PNG Blob plus metadata:
+ *   `{ blob, mimeType, extension, width, height }`.
+ */
+function getMapScreenshot() {
+    //We need to manually order leaflet z-indices for this to work
+    let zIndices = []
+    jquery('#map .leaflet-tile-pane')
+        .children()
+        .each(function (i, elm) {
+            zIndices.push(jquery(elm).css('z-index'))
+            jquery(elm).css('z-index', i + 1)
+        })
+    jquery('.leaflet-control-scalefactor').css('display', 'none')
+    jquery('#mmgis-map-compass').css('display', 'none')
+    jquery('.leaflet-control-zoom').css('display', 'none')
+    jquery('#scaleBar').css('margin-top', '0px')
+    const savedMapToolBarBottom = jquery('#mapToolBar').css('bottom') || '0px'
+    jquery('#mapToolBar').css('bottom', '0px')
+    // Collapse the time UI so it stays out of the capture; remember whether it
+    // was open so we can restore it afterwards (the click removes the .active
+    // class, so the restore re-triggers the plain #toggleTimeUI selector).
+    const timeUIWasActive = jquery('#toggleTimeUI.active').length > 0
+    if (timeUIWasActive) jquery('#toggleTimeUI.active').trigger('click')
+
+    // Snapshot now — after the z-index normalization, before the restore —
+    // because onclone fires after the restore has already run.
+    const paneStyles = snapshotLeafletPaneStyles({
+        svgSelector: 'svg.leaflet-zoom-animated',
+        tileSelector: '.leaflet-tile-pane > div.leaflet-layer',
+    })
+
+    // Split out so the error paths below can restore the hidden UI too.
+    const restoreChrome = function () {
+        jquery('#map .leaflet-tile-pane')
+            .children()
+            .each(function (i, elm) {
+                jquery(elm).css('z-index', zIndices[i])
+            })
+        jquery('.leaflet-control-scalefactor').css('display', 'flex')
+        jquery('#mmgis-map-compass').css('display', 'block')
+        jquery('.leaflet-control-zoom').css('display', 'block')
+        jquery('#scaleBar').css('margin-top', '5px')
+        jquery('#mapToolBar').css('bottom', savedMapToolBarBottom)
+        if (timeUIWasActive) jquery('#toggleTimeUI').trigger('click')
+    }
+
+    // The classic UI wraps the map in #mapScreen; the modern layout has no such
+    // wrapper, so fall back to the #map container (present in both layouts).
+    const documentElm =
+        document.getElementById('mapScreen') || document.getElementById('map')
+    if (!documentElm) {
+        restoreChrome()
+        return Promise.reject(
+            new Error('getMapScreenshot: no #mapScreen/#map container to capture')
+        )
+    }
+
+    let capture
+    try {
+        capture = html2canvas(documentElm, {
+            allowTaint: true,
+            useCORS: true,
+            logging: false,
+            scrollX: -window.scrollX,
+            scrollY: -window.scrollY,
+            windowWidth: documentElm.offsetWidth,
+            windowHeight: documentElm.offsetHeight,
+            onclone: function (e) {
+                applyLeafletCloneFixups(e.body, paneStyles)
+            },
+        }).then(canvasToPngScreenshot)
+    } catch (err) {
+        restoreChrome()
+        throw err
+    }
+
+    // Restore immediately (not in .then) so the UI isn't visibly degraded
+    // during the capture: html2canvas clones the DOM synchronously above, and
+    // the onclone fixups use the pre-restore snapshot.
+    restoreChrome()
+
+    return capture
+}
+
+function canvasToPngScreenshot(canvas) {
+    return new Promise(function (resolve, reject) {
+        if (typeof canvas.toBlob !== 'function') {
+            reject(new Error('getMapScreenshot: canvas.toBlob is unavailable'))
+            return
+        }
+        canvas.toBlob(function (blob) {
+            if (!blob) {
+                reject(new Error('getMapScreenshot: canvas.toBlob returned null'))
+                return
+            }
+            resolve({
+                blob,
+                mimeType: 'image/png',
+                extension: 'png',
+                width: canvas.width,
+                height: canvas.height,
+            })
+        }, 'image/png')
+    })
+}
+
+export { getMapScreenshot }
diff --git a/src/essence/Basics/MapEngines/IMapEngine.ts b/src/essence/Basics/MapEngines/IMapEngine.ts
index 9493c40fe..780807963 100644
--- a/src/essence/Basics/MapEngines/IMapEngine.ts
+++ b/src/essence/Basics/MapEngines/IMapEngine.ts
@@ -18,6 +18,14 @@ import {
 } from './types/events'
 import { MapEngineType } from './types/engine'
 
+export interface MapScreenshotResult {
+    blob: Blob
+    mimeType: 'image/png'
+    extension: 'png'
+    width: number
+    height: number
+}
+
 /**
  * Core map engine contract.
  *
@@ -65,6 +73,18 @@ export interface IMapEngine<
      */
     getContainer(): HTMLElement
 
+    /**
+     * Capture the current map view as a PNG image.
+     *
+     * Each engine owns the capture strategy for its rendering technology:
+     * - Leaflet rasterizes its DOM/SVG/tile panes with html2canvas.
+     * - deck.gl reads the WebGL canvas directly (the base map's GL context
+     *   when running in interleaved overlay mode), which html2canvas cannot do.
+     *
+     * @returns Resolves to a PNG image Blob plus metadata.
+     */
+    captureScreenshot(): Promise<MapScreenshotResult>
+
     /**
      * Jump to a center and zoom without animation.
      */
diff --git a/src/essence/Basics/Map_/Map_.js b/src/essence/Basics/Map_/Map_.js
index be64667d0..5240ce5db 100644
--- a/src/essence/Basics/Map_/Map_.js
+++ b/src/essence/Basics/Map_/Map_.js
@@ -431,7 +431,9 @@ let Map_ = {
         if (isNaN(lat)) lat = 0
         var lon = parseFloat(latlonzoom[1])
         if (isNaN(lon)) lon = 0
-        var zoom = parseInt(latlonzoom[2])
+        // parseFloat: the modern map zooms fractionally; truncating here
+        // visibly changes restored views (Leaflet snaps integers itself).
+        var zoom = parseFloat(latlonzoom[2])
         if (zoom == null || isNaN(zoom))
             zoom =
                 this.engine.getZoom() ||
diff --git a/src/essence/Basics/UserInterface_/BottomBar.js b/src/essence/Basics/UserInterface_/BottomBar.js
index f4bc7d2a3..8c58c1423 100644
--- a/src/essence/Basics/UserInterface_/BottomBar.js
+++ b/src/essence/Basics/UserInterface_/BottomBar.js
@@ -6,7 +6,6 @@ import L_ from '../Layers_/Layers_'
 
 import QueryURL from '../../Ancillary/QueryURL'
 import Modal from '../../Ancillary/Modal'
-import HTML2Canvas from 'html2canvas'
 import tippy from 'tippy.js'
 
 import './BottomBar.css'
@@ -32,17 +31,20 @@ let BottomBar = {
             })
             .on('click', function () {
                 const linkButton = $(this)
-                QueryURL.writeCoordinateURL(true, function () {
-                    F_.copyToClipboard(L_.url)
-
-                    linkButton.removeClass('mdi-open-in-new')
-                    linkButton.addClass('mdi-check-bold')
-                    linkButton.css('color', 'var(--color-green)')
-                    setTimeout(() => {
-                        linkButton.removeClass('mdi-check-bold')
-                        linkButton.css('color', '')
-                        linkButton.addClass('mdi-open-in-new')
-                    }, 3000)
+                QueryURL.getShareURL(function (url) {
+                    L_.url = url
+                    window.history.replaceState('', '', L_.url)
+                    F_.copyToClipboard(L_.url).then((copied) => {
+                        if (!copied) return
+                        linkButton.removeClass('mdi-open-in-new')
+                        linkButton.addClass('mdi-check-bold')
+                        linkButton.css('color', 'var(--color-green)')
+                        setTimeout(() => {
+                            linkButton.removeClass('mdi-check-bold')
+                            linkButton.css('color', '')
+                            linkButton.addClass('mdi-open-in-new')
+                        }, 3000)
+                    })
                 })
             })
         bottomBar.append(topBarLink)
@@ -68,104 +70,37 @@ let BottomBar = {
                 'opacity': '0.8'
             })
             .on('click', function () {
-                //We need to manually order leaflet z-indices for this to work
-                let zIndices = []
-                $('#mapScreen #map .leaflet-tile-pane')
-                    .children()
-                    .each(function (i, elm) {
-                        zIndices.push($(elm).css('z-index'))
-                        $(elm).css('z-index', i + 1)
-                    })
-                $('.leaflet-control-scalefactor').css('display', 'none')
-                $('#mmgis-map-compass').css('display', 'none')
-                $('.leaflet-control-zoom').css('display', 'none')
+                // Screenshot capture is engine-aware: it flows through
+                // mmgisAPI.getMapScreenshot(), which delegates to the active
+                // map engine (Leaflet html2canvas vs deck.gl GL-canvas
+                // readback). Here we just show the loading spinner, then
+                // download the resulting PNG Blob.
                 $('#topBarScreenshotLoading').css('display', 'block')
-                $('#scaleBar').css('margin-top', '0px')
-                const savedMapToolBarBottom =
-                    $('#mapToolBar').css('bottom') || '0px'
-                $('#mapToolBar').css('bottom', '0px')
-                $(`#toggleTimeUI.active`).trigger('click')
 
-                const documentElm = document.getElementById('mapScreen')
-                HTML2Canvas(documentElm, {
-                    allowTaint: true,
-                    useCORS: true,
-                    logging: false,
-                    scrollX: -window.scrollX,
-                    scrollY: -window.scrollY,
-                    windowWidth: documentElm.offsetWidth,
-                    windowHeight: documentElm.offsetHeight,
-                    onclone: function (e) {
-                        // Fix svg layer shift
-                        const originalSVG = document.body.querySelectorAll(
-                            'svg.leaflet-zoom-animated'
-                        )
-                        const copySVG = e.body.querySelectorAll(
-                            'svg.leaflet-zoom-animated'
-                        )
-                        copySVG.forEach((copyEle, i) => {
-                            const attribute = originalSVG
-                                .item(i)
-                                .getAttribute('style')
-                            const parentElement = copyEle.parentElement
-                            parentElement.removeChild(copyEle)
-                            const temp = document.createElement('div')
-                            temp.appendChild(copyEle)
-                            parentElement.appendChild(temp)
-                            temp.setAttribute('style', attribute)
-                            copyEle.removeAttribute('style')
-                        })
-
-                        // Fix tile layer z-indices
-                        const originalZ = document.body.querySelectorAll(
-                            '.leaflet-tile-pane > div.leaflet-layer'
-                        )
-                        const copyZ = e.body.querySelectorAll(
-                            '.leaflet-tile-pane > div.leaflet-layer'
-                        )
-                        copyZ.forEach((copyEle, i) => {
-                            const attribute = originalZ
-                                .item(i)
-                                .getAttribute('style')
-                            copyEle.setAttribute('style', attribute)
-                        })
-                    },
-                }).then(function (canvas) {
-                    canvas.id = 'mmgisScreenshot'
-                    document.body.appendChild(canvas)
+                window.mmgisAPI
+                    .getMapScreenshot()
+                    .then(function (screenshot) {
+                        // L_.mission is the mission's canonical identity (the ?mission= value);
+                        // configData.msv.mission is a display field that can be stale.
+                        const mission = L_.mission || L_.configData?.msv?.mission
+                        const time = L_.TimeControl_?.currentTime
+                        const mapCenter = L_.Map_.map.getCenter()
+                        const lng = mapCenter.lng.toFixed(4)
+                        const lat = mapCenter.lat.toFixed(4)
+                        const name = `mmgis-${mission}_${
+                            time ? `${time.replaceAll(':', '-')}_` : ''
+                        }${lat}_${lng}.png`
 
-                    const mission = L_.configData?.msv?.mission
-                    const time = L_.TimeControl_?.currentTime
-                    const mapCenter = L_.Map_.map.getCenter()
-                    const lng = mapCenter.lng.toFixed(4)
-                    const lat = mapCenter.lat.toFixed(4)
+                        F_.downloadBlob(screenshot.blob, name)
 
-                    F_.downloadCanvas(
-                        canvas.id,
-                        `mmgis-${mission}_${
-                            time ? `${time.replaceAll(':', '-')}_` : ''
-                        }${lat}_${lng}`,
-                        function () {
-                            canvas.remove()
-                            setTimeout(function () {
-                                $('#topBarScreenshotLoading').css(
-                                    'display',
-                                    'none'
-                                )
-                            }, 2000)
-                        }
-                    )
-                })
-                $('#mapScreen #map .leaflet-tile-pane')
-                    .children()
-                    .each(function (i, elm) {
-                        $(elm).css('z-index', zIndices[i])
+                        setTimeout(function () {
+                            $('#topBarScreenshotLoading').css('display', 'none')
+                        }, 2000)
+                    })
+                    .catch(function (err) {
+                        console.error('Screenshot failed:', err)
+                        $('#topBarScreenshotLoading').css('display', 'none')
                     })
-                $('.leaflet-control-scalefactor').css('display', 'flex')
-                $('#mmgis-map-compass').css('display', 'block')
-                $('.leaflet-control-zoom').css('display', 'block')
-                $('#scaleBar').css('margin-top', '5px')
-                $('#mapToolBar').css('bottom', 'savedMapToolBarBottom')
             })
         bottomBar.append(topBarScreenshot)
 
diff --git a/src/essence/Tools/Animation/OffscreenMapManager.js b/src/essence/Tools/Animation/OffscreenMapManager.js
index c1224e4f4..6a4a8987a 100644
--- a/src/essence/Tools/Animation/OffscreenMapManager.js
+++ b/src/essence/Tools/Animation/OffscreenMapManager.js
@@ -20,6 +20,10 @@ import L_ from '../../Basics/Layers_/Layers_'
 import Map_ from '../../Basics/Map_/Map_'
 import F_ from '../../Basics/Formulae_/Formulae_'
 import HTML2Canvas from 'html2canvas'
+import {
+    snapshotLeafletPaneStyles,
+    applyLeafletCloneFixups,
+} from '../../Basics/MapEngines/Adapters/LeafletCloneFixups'
 
 // Access Leaflet from global window object
 const L = window.L
@@ -620,6 +624,16 @@ class OffscreenMapManager {
             // Wait a bit for Leaflet to render (asynchronous rendering)
             await new Promise((resolve) => setTimeout(resolve, 100))
 
+            // Snapshot the pane styles for the shared Leaflet/html2canvas
+            // clone fixups (SVG re-parenting, tile z-index copy); the
+            // selectors scope them to the offscreen map only.
+            const paneStyles = snapshotLeafletPaneStyles({
+                svgSelector:
+                    '#offscreen-map-container .leaflet-overlay-pane > svg',
+                tileSelector:
+                    '#offscreen-map-container .leaflet-tile-pane > div.leaflet-layer',
+            })
+
             // Capture using HTML2Canvas
             const canvas = await HTML2Canvas(this.container, {
                 allowTaint: true,
@@ -635,41 +649,7 @@ class OffscreenMapManager {
                 windowWidth: this.container.offsetWidth,
                 windowHeight: this.container.offsetHeight,
 
-                onclone: function (e) {
-                    // Fix svg layer shift
-                    const originalSVG = document.body.querySelectorAll(
-                        '#offscreen-map-container .leaflet-overlay-pane > svg'
-                    )
-                    const copySVG = e.body.querySelectorAll(
-                        '#offscreen-map-container .leaflet-overlay-pane > svg'
-                    )
-                    copySVG.forEach((copyEle, i) => {
-                        const attribute = originalSVG
-                            .item(i)
-                            .getAttribute('style')
-                        const parentElement = copyEle.parentElement
-                        parentElement.removeChild(copyEle)
-                        const temp = document.createElement('div')
-                        temp.appendChild(copyEle)
-                        parentElement.appendChild(temp)
-                        temp.setAttribute('style', attribute)
-                        copyEle.removeAttribute('style')
-                    })
-
-                    // Fix tile layer z-indices
-                    const originalZ = document.body.querySelectorAll(
-                        '#offscreen-map-container .leaflet-tile-pane > div.leaflet-layer'
-                    )
-                    const copyZ = e.body.querySelectorAll(
-                        '#offscreen-map-container .leaflet-tile-pane > div.leaflet-layer'
-                    )
-                    copyZ.forEach((copyEle, i) => {
-                        const attribute = originalZ
-                            .item(i)
-                            .getAttribute('style')
-                        copyEle.setAttribute('style', attribute)
-                    })
-                },
+                onclone: (e) => applyLeafletCloneFixups(e.body, paneStyles),
             })
 
             // Since the offscreen container was sized to match the drawn bbox dimensions
diff --git a/src/essence/Tools/Info/InfoTool.js b/src/essence/Tools/Info/InfoTool.js
index 04d85db3b..94a3611b6 100644
--- a/src/essence/Tools/Info/InfoTool.js
+++ b/src/essence/Tools/Info/InfoTool.js
@@ -310,17 +310,20 @@ var InfoTool = {
             const feature = L_.convertGeoJSONLngLatsToPrimaryCoordinates(
                 InfoTool.info[InfoTool.activeFeatureI]
             )
-            F_.copyToClipboard(JSON.stringify(feature, null, 2))
-
             const icon = $(this).find('i')
-            icon.removeClass('mdi-clipboard-outline')
-            icon.addClass('mdi-check-bold')
-            icon.css('color', 'var(--color-green)')
-            setTimeout(() => {
-                icon.removeClass('mdi-check-bold')
-                icon.css('color', 'inherit')
-                icon.addClass('mdi-clipboard-outline')
-            }, 3000)
+            F_.copyToClipboard(JSON.stringify(feature, null, 2)).then(
+                (copied) => {
+                    if (!copied) return
+                    icon.removeClass('mdi-clipboard-outline')
+                    icon.addClass('mdi-check-bold')
+                    icon.css('color', 'var(--color-green)')
+                    setTimeout(() => {
+                        icon.removeClass('mdi-check-bold')
+                        icon.css('color', 'inherit')
+                        icon.addClass('mdi-clipboard-outline')
+                    }, 3000)
+                }
+            )
         })
 
         // Locate
diff --git a/src/essence/mmgisAPI/mmgisAPI.js b/src/essence/mmgisAPI/mmgisAPI.js
index cc4c05e86..1559caabb 100644
--- a/src/essence/mmgisAPI/mmgisAPI.js
+++ b/src/essence/mmgisAPI/mmgisAPI.js
@@ -438,7 +438,47 @@ var mmgisAPI_ = {
         return validEvents.includes(eventName)
     },
     writeCoordinateURL: function () {
-        return QueryURL.writeCoordinateURL(false)
+        // The URL builder dereferences objects that only exist after mission
+        // finalization; return null (the "no link yet" signal) until then.
+        if (mmgisAPI_.map == null) return null
+        return QueryURL.writeCoordinateURL()
+    },
+    copyText: function (text) {
+        return F_.copyToClipboard(text)
+    },
+    getViewState: function () {
+        // View metadata for plugins; fields are null until loaded.
+        const map = L_.Map_ && L_.Map_.map
+        const center =
+            map && typeof map.getCenter === 'function' ? map.getCenter() : null
+        return {
+            // L_.mission is the canonical identity (the ?mission= URL value);
+            // msv.mission is a display field that can be stale.
+            missionName: L_.mission || L_.configData?.msv?.mission || null,
+            time: L_.TimeControl_?.currentTime ?? null,
+            center: center ? { lat: center.lat, lng: center.lng } : null,
+            zoom:
+                map && typeof map.getZoom === 'function'
+                    ? map.getZoom()
+                    : null,
+        }
+    },
+    getMapScreenshot: function () {
+        // Capture is engine-specific (Leaflet DOM rasterization vs deck.gl
+        // canvas readback); delegate to the active IMapEngine adapter. A
+        // missing engine means no map is loaded yet.
+        const engine = L_.Map_ && L_.Map_.engine
+        if (engine && typeof engine.captureScreenshot === 'function') {
+            // Convert a sync engine throw into a rejection.
+            try {
+                return Promise.resolve(engine.captureScreenshot())
+            } catch (err) {
+                return Promise.reject(err)
+            }
+        }
+        return Promise.reject(
+            new Error('getMapScreenshot: no active map engine to capture')
+        )
     },
     onLoadCallback: null,
     onLoaded: function (onLoadCallback) {
@@ -719,10 +759,37 @@ var mmgisAPI = {
 
     /** writeCoordinateURL - writes out the current view as a url. This returns the long form of
      * the 'Copy Link' feature and does not save a short url to the database.
-     * @returns {string} - a string containing the current view as a url
+     * @returns {string|null} - a string containing the current view as a url, or null if the mission has not finished loading yet
      */
     writeCoordinateURL: mmgisAPI_.writeCoordinateURL,
 
+    /** getViewState - returns metadata about the current view (for example to
+     * build provenance-rich export filenames). Fields are null until the
+     * mission has loaded far enough to answer them.
+     * @returns {object} {missionName: string|null, time: string|null, center: {lat, lng}|null, zoom: number|null}
+     */
+    getViewState: mmgisAPI_.getViewState,
+
+    /** copyText - copies text to the user's clipboard. Uses the async
+     * Clipboard API with a legacy fallback for insecure origins. Note: pages
+     * embedding MMGIS in an iframe (FRAME_ANCESTORS) must set
+     * allow="clipboard-write" for the modern path.
+     * @param {string} text - text to copy
+     * @returns {Promise<boolean>} true on success, false on failure — never rejects
+     */
+    copyText: mmgisAPI_.copyText,
+
+    /** getMapScreenshot - captures a PNG screenshot of the current map view.
+     * Delegates to the active map engine, so the capture strategy is
+     * engine-specific: the Leaflet engine rasterizes its DOM (hiding UI chrome
+     * for the shot), while the deck.gl/GL engine reads its WebGL canvas. Note
+     * that the deck.gl capture is limited to the GL canvas and does not include
+     * HTML overlays/markers layered on top. Asynchronous; requires no backend
+     * call. Rejects if no map engine is active.
+     * @returns {Promise<{blob: Blob, mimeType: 'image/png', extension: 'png', width: number, height: number}>} - resolves to a PNG Blob plus image metadata.
+     */
+    getMapScreenshot: mmgisAPI_.getMapScreenshot,
+
     /** onLoaded - calls onLoadCallback as a function once MMGIS has finished loading.
      * @param {function} - onLoadCallback - function reference to function that is called when MMGIS is finished loading
      */
diff --git a/src/pre/calls.js b/src/pre/calls.js
index 1cfe8cf0a..dcef97e5a 100644
--- a/src/pre/calls.js
+++ b/src/pre/calls.js
@@ -117,10 +117,10 @@ const c = {
         type: 'POST',
         url: 'api/files/gethistory',
     },
-    shortener_shorten: {
-        type: 'POST',
-        url: 'api/shortener/shorten',
-    },
+    shortener_shorten: {
+        type: 'POST',
+        url: 'api/shortener/shorten',
+    },
     shortener_expand: {
         type: 'POST',
         url: 'api/shortener/expand',
diff --git a/tests/unit/LeafletAdapter.spec.js b/tests/unit/LeafletAdapter.spec.js
index 0a86fa477..95018467b 100644
--- a/tests/unit/LeafletAdapter.spec.js
+++ b/tests/unit/LeafletAdapter.spec.js
@@ -1,6 +1,21 @@
-import { test, expect } from 'vitest'
+import { test, expect, vi } from 'vitest'
 import LeafletAdapter from '../../src/essence/Basics/MapEngines/Adapters/LeafletAdapter.ts'
 import { MAP_ENGINE } from '../../src/essence/Basics/MapEngines/types/engine.ts'
+import { getMapScreenshot as mockedLeafletCapture } from '../../src/essence/Basics/MapEngines/Adapters/LeafletScreenshot.js'
+
+// Mock the Leaflet screenshot strategy so we can assert LeafletAdapter delegates
+// to it (issue #143) without driving the real html2canvas/DOM path.
+vi.mock('../../src/essence/Basics/MapEngines/Adapters/LeafletScreenshot.js', () => {
+    const result = {
+        blob: new Blob(['leaflet'], { type: 'image/png' }),
+        mimeType: 'image/png',
+        extension: 'png',
+        width: 640,
+        height: 480,
+    }
+    const fn = vi.fn(() => Promise.resolve(result))
+    return { getMapScreenshot: fn, default: fn }
+})
 
 
 /**
@@ -143,6 +158,25 @@ test.describe('LeafletAdapter - Lifecycle', () => {
         expect(adapter.getNativeMap()).toBeNull()
     })
 
+    test('captureScreenshot() delegates to the Leaflet screenshot strategy', async () => {
+        // The engine-aware screenshot path (issue #143) requires every adapter
+        // to implement captureScreenshot(). LeafletAdapter delegates to the
+        // Leaflet screenshot helper; assert it actually calls it and returns the
+        // helper's promise (not just that the method exists).
+        const adapter = new LeafletAdapter()
+        expect(typeof adapter.captureScreenshot).toBe('function')
+
+        mockedLeafletCapture.mockClear()
+        const result = await adapter.captureScreenshot()
+
+        expect(mockedLeafletCapture).toHaveBeenCalledTimes(1)
+        expect(result.mimeType).toBe('image/png')
+        expect(result.extension).toBe('png')
+        expect(result.width).toBe(640)
+        expect(result.height).toBe(480)
+        expect(result.blob).toBeInstanceOf(Blob)
+    })
+
     test('destroy() is safe to call when map is not initialized', () => {
         setup()
         const adapter = new LeafletAdapter()
diff --git a/tests/unit/copyText.spec.js b/tests/unit/copyText.spec.js
new file mode 100644
index 000000000..13114c3e1
--- /dev/null
+++ b/tests/unit/copyText.spec.js
@@ -0,0 +1,78 @@
+import { test, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// Viewer_ pulls in Photosphere/ModelViewer/PDFViewer, which are JSX written in
+// .js files that vite's import-analysis can't parse. Nothing in this test needs
+// the real viewers, so stub the aggregator to keep the mmgisAPI import chain
+// parseable in the jsdom test env.
+vi.mock('../../src/essence/Basics/Viewer_/Viewer_', () => ({ default: {} }))
+
+import { mmgisAPI } from '../../src/essence/mmgisAPI/mmgisAPI'
+
+// Issue #143 review follow-up - mmgisAPI.copyText(text) resolves true/false and
+// never rejects: navigator.clipboard.writeText first, falling back to the
+// hidden-textarea + execCommand path when the modern API is absent (insecure
+// origin) OR rejects (iframe without clipboard-write, expired user gesture).
+
+function setClipboard(value) {
+    Object.defineProperty(window.navigator, 'clipboard', {
+        value,
+        configurable: true,
+    })
+}
+
+test.describe('mmgisAPI.copyText', () => {
+    beforeEach(() => {
+        document.execCommand = vi.fn(() => true)
+    })
+    afterEach(() => {
+        setClipboard(undefined)
+        delete document.execCommand
+    })
+
+    test('uses the async Clipboard API when available', async () => {
+        const writeText = vi.fn(() => Promise.resolve())
+        setClipboard({ writeText })
+
+        await expect(mmgisAPI.copyText('hello')).resolves.toBe(true)
+        expect(writeText).toHaveBeenCalledWith('hello')
+        expect(document.execCommand).not.toHaveBeenCalled()
+    })
+
+    test('falls back to execCommand when the modern API rejects', async () => {
+        // e.g. an embedding iframe without allow="clipboard-write".
+        setClipboard({ writeText: vi.fn(() => Promise.reject(new Error('denied'))) })
+
+        await expect(mmgisAPI.copyText('hello')).resolves.toBe(true)
+        expect(document.execCommand).toHaveBeenCalledWith('copy')
+        // The transient textarea must not leak into the document.
+        expect(document.querySelectorAll('textarea').length).toBe(0)
+    })
+
+    test('falls back to execCommand when the modern API is absent', async () => {
+        setClipboard(undefined)
+
+        await expect(mmgisAPI.copyText('hello')).resolves.toBe(true)
+        expect(document.execCommand).toHaveBeenCalledWith('copy')
+    })
+
+    test('resolves false (never rejects) when every path fails', async () => {
+        setClipboard(undefined)
+        document.execCommand = vi.fn(() => {
+            throw new Error('unsupported')
+        })
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+        await expect(mmgisAPI.copyText('hello')).resolves.toBe(false)
+        expect(document.querySelectorAll('textarea').length).toBe(0)
+        warn.mockRestore()
+    })
+
+    test('resolves false when execCommand reports failure', async () => {
+        setClipboard(undefined)
+        document.execCommand = vi.fn(() => false)
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {})
+
+        await expect(mmgisAPI.copyText('hello')).resolves.toBe(false)
+        warn.mockRestore()
+    })
+})
diff --git a/tests/unit/deckGLAdapter.spec.js b/tests/unit/deckGLAdapter.spec.js
index bf2acf78f..7301658f0 100644
--- a/tests/unit/deckGLAdapter.spec.js
+++ b/tests/unit/deckGLAdapter.spec.js
@@ -1,6 +1,9 @@
-import { test, expect } from 'vitest'
+import { test, expect, vi } from 'vitest'
 import { DeckGLAdapter } from '../../src/essence/Basics/MapEngines/Adapters/DeckGLAdapter.ts'
-import { MAP_ENGINE } from '../../src/essence/Basics/MapEngines/index.ts'
+// Import MAP_ENGINE from the lightweight types module rather than MapEngines/index.ts.
+// index.ts transitively imports LeafletAdapter -> leaflet, which references a global
+// `window` at module-eval time and fails in this Node test context.
+import { MAP_ENGINE } from '../../src/essence/Basics/MapEngines/types/engine.ts'
 
 function makeAdapter({ longitude = -120, latitude = 40, zoom = 5 } = {}) {
     const adapter = new DeckGLAdapter()
@@ -215,6 +218,136 @@ test.describe('DeckGLAdapter', () => {
         })
     })
 
+    test.describe('captureScreenshot', () => {
+        test('overlay mode reads the canvas inside the render event after triggerRepaint', async () => {
+            const adapter = makeAdapter()
+            let inRenderFrame = false
+            let renderHandler = null
+            const blob = new Blob(['deckgl'], { type: 'image/png' })
+            const canvas = {
+                width: 256,
+                height: 128,
+                toBlob: (callback, type) => {
+                    expect(type).toBe('image/png')
+                    // Only valid during the render event, before the browser
+                    // presents (and clears) the drawing buffer.
+                    callback(inRenderFrame ? blob : null)
+                },
+            }
+            adapter._isOverlayMode = true
+            adapter._basemap = {
+                once: (type, handler) => {
+                    expect(type).toBe('render')
+                    renderHandler = handler
+                },
+                triggerRepaint: () => {
+                    // Simulate the frame the repaint schedules: the map draws,
+                    // fires 'render' while the buffer still holds pixels, then
+                    // the buffer is cleared on present.
+                    inRenderFrame = true
+                    renderHandler()
+                    inRenderFrame = false
+                },
+                getCanvas: () => canvas,
+            }
+
+            const result = await adapter.captureScreenshot()
+            expect(result).toEqual({
+                blob,
+                mimeType: 'image/png',
+                extension: 'png',
+                width: 256,
+                height: 128,
+            })
+        })
+
+        test('overlay mode rejects when toBlob returns null during the render event', async () => {
+            const adapter = makeAdapter()
+            let renderHandler = null
+            adapter._isOverlayMode = true
+            adapter._basemap = {
+                once: (_type, handler) => { renderHandler = handler },
+                triggerRepaint: () => renderHandler(),
+                getCanvas: () => ({
+                    width: 256,
+                    height: 128,
+                    toBlob: (callback) => callback(null),
+                }),
+            }
+
+            await expect(adapter.captureScreenshot()).rejects.toThrow(/toBlob returned null/)
+        })
+
+        test('overlay mode rejects after the timeout if the render event never fires', async () => {
+            vi.useFakeTimers()
+            try {
+                const adapter = makeAdapter()
+                let repainted = false
+                let armedHandler = null
+                const removed = []
+                adapter._isOverlayMode = true
+                adapter._basemap = {
+                    once: (type, handler) => { armedHandler = handler },
+                    off: (type, handler) => { removed.push({ type, handler }) },
+                    triggerRepaint: () => { repainted = true },
+                    getCanvas: () => ({
+                        width: 256,
+                        height: 128,
+                        toBlob: () => {},
+                    }),
+                }
+
+                const capture = adapter.captureScreenshot()
+                const assertion = expect(capture).rejects.toThrow(/timed out/)
+                vi.advanceTimersByTime(3000)
+                await assertion
+                expect(repainted).toBe(true)
+                // The timeout must unhook the pending render listener, or a
+                // timed-out capture leaves it armed to fire on a later render.
+                expect(removed).toEqual([
+                    { type: 'render', handler: armedHandler },
+                ])
+            } finally {
+                vi.useRealTimers()
+            }
+        })
+
+        test('standalone mode redraws deck and reads its canvas', async () => {
+            const adapter = makeAdapter()
+            let redrawArg = null
+            const blob = new Blob(['standalone'], { type: 'image/png' })
+            adapter._isOverlayMode = false
+            adapter._deck = {
+                redraw: (reason) => { redrawArg = reason },
+                getCanvas: () => ({
+                    width: 300,
+                    height: 200,
+                    toBlob: (callback, type) => {
+                        expect(type).toBe('image/png')
+                        callback(blob)
+                    },
+                }),
+            }
+
+            const result = await adapter.captureScreenshot()
+            expect(redrawArg).toBe('screenshot')
+            expect(result).toEqual({
+                blob,
+                mimeType: 'image/png',
+                extension: 'png',
+                width: 300,
+                height: 200,
+            })
+        })
+
+        test('rejects when there is no active map to capture', async () => {
+            const adapter = makeAdapter()
+            adapter._isOverlayMode = false
+            adapter._deck = null
+            await expect(adapter.captureScreenshot()).rejects.toThrow(/no active map/)
+        })
+    })
+
     test.describe('destroy', () => {
         test('clears all layers', () => {
             const adapter = makeAdapter()
diff --git a/tests/unit/deckGLScreenshotConfig.spec.js b/tests/unit/deckGLScreenshotConfig.spec.js
new file mode 100644
index 000000000..9a8e781d1
--- /dev/null
+++ b/tests/unit/deckGLScreenshotConfig.spec.js
@@ -0,0 +1,96 @@
+import { test, expect, vi, beforeEach } from 'vitest'
+
+// Issue #143 - the deck.gl screenshot path captures on demand instead of
+// paying the per-frame cost of `preserveDrawingBuffer: true`:
+// - overlay mode reads the canvas inside a once('render') handler after
+//   triggerRepaint(), in the same frame the map draws (before the browser
+//   presents and clears the buffer);
+// - standalone mode reads immediately after deck.redraw('screenshot'), which
+//   draws synchronously in deck.gl v9.
+// Nothing should request preserveDrawingBuffer at init time any more. These
+// tests drive the real init() path with the GL constructors mocked and assert
+// the flag is absent on both the standalone (Deck) and overlay (maplibre Map)
+// paths — a regression guard against reintroducing the always-on buffer copy.
+
+const deckCtorArgs = []
+const maplibreCtorArgs = []
+
+vi.mock('@deck.gl/core', async (importOriginal) => {
+    // Keep the real interpolators etc.; only the Deck constructor is replaced so
+    // no real WebGL context is created (jsdom has none).
+    const actual = await importOriginal()
+    class MockDeck {
+        constructor(props) {
+            deckCtorArgs.push(props)
+        }
+        setProps() {}
+        redraw() {}
+        finalize() {}
+        getCanvas() {
+            return { toDataURL: () => 'data:image/png;base64,MOCK' }
+        }
+    }
+    return { ...actual, Deck: MockDeck }
+})
+
+vi.mock('maplibre-gl', () => {
+    class MockMap {
+        constructor(opts) {
+            maplibreCtorArgs.push(opts)
+        }
+        addControl() {}
+        on() {}
+        once() {}
+        off() {}
+        setMaxBounds() {}
+        remove() {}
+        getCanvas() {
+            return { toDataURL: () => 'data:image/png;base64,MOCK' }
+        }
+    }
+    return { Map: MockMap, default: { Map: MockMap } }
+})
+
+// Imported after the mocks are declared (vi.mock is hoisted regardless).
+const { DeckGLAdapter } = await import(
+    '../../src/essence/Basics/MapEngines/Adapters/DeckGLAdapter.ts'
+)
+
+function makeContainer(id = 'map') {
+    let el = document.getElementById(id)
+    if (!el) {
+        el = document.createElement('div')
+        el.id = id
+        document.body.appendChild(el)
+    }
+    return el
+}
+
+test.describe('DeckGLAdapter init does not set preserveDrawingBuffer (issue #143)', () => {
+    beforeEach(() => {
+        deckCtorArgs.length = 0
+        maplibreCtorArgs.length = 0
+        makeContainer('map')
+    })
+
+    test('standalone mode creates the Deck without preserveDrawingBuffer deviceProps', () => {
+        const adapter = new DeckGLAdapter()
+        adapter.init({ containerId: 'map', zoom: 4, center: { lat: 0, lng: 0 } })
+
+        expect(deckCtorArgs).toHaveLength(1)
+        expect(deckCtorArgs[0].deviceProps?.webgl?.preserveDrawingBuffer).toBeUndefined()
+    })
+
+    test('maplibre overlay mode creates the Map without preserveDrawingBuffer', () => {
+        const adapter = new DeckGLAdapter()
+        adapter.init({
+            containerId: 'map',
+            zoom: 4,
+            center: { lat: 0, lng: 0 },
+            basemap: { provider: 'maplibre', style: 'https://example/style.json' },
+        })
+
+        expect(maplibreCtorArgs).toHaveLength(1)
+        expect(maplibreCtorArgs[0].preserveDrawingBuffer).toBeUndefined()
+    })
+})
diff --git a/tests/unit/mmgisApiScreenshot.spec.js b/tests/unit/mmgisApiScreenshot.spec.js
new file mode 100644
index 000000000..026c16095
--- /dev/null
+++ b/tests/unit/mmgisApiScreenshot.spec.js
@@ -0,0 +1,74 @@
+import { test, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// Viewer_ pulls in Photosphere/ModelViewer/PDFViewer, which are JSX written in
+// .js files that vite's import-analysis can't parse. Nothing in this test needs
+// the real viewers, so stub the aggregator to keep the mmgisAPI import chain
+// parseable in the jsdom test env.
+vi.mock('../../src/essence/Basics/Viewer_/Viewer_', () => ({ default: {} }))
+
+import { mmgisAPI } from '../../src/essence/mmgisAPI/mmgisAPI'
+import L_ from '../../src/essence/Basics/Layers_/Layers_'
+
+// Issue #143 - mmgisAPI.getMapScreenshot() is the public, engine-aware entry
+// point. It must delegate to the active map engine's captureScreenshot() and
+// reject when no engine is loaded (rather than reach into a specific engine's
+// DOM). L_ is a shared singleton, so we drive L_.Map_.engine directly.
+
+test.describe('mmgisAPI.getMapScreenshot delegation (issue #143)', () => {
+    let savedMap
+    beforeEach(() => {
+        savedMap = L_.Map_
+    })
+    afterEach(() => {
+        L_.Map_ = savedMap
+    })
+
+    test('delegates to the active engine and returns its result', async () => {
+        const screenshot = {
+            blob: new Blob(['engine'], { type: 'image/png' }),
+            mimeType: 'image/png',
+            extension: 'png',
+            width: 640,
+            height: 480,
+        }
+        const capture = vi.fn(() =>
+            Promise.resolve(screenshot)
+        )
+        L_.Map_ = { engine: { captureScreenshot: capture } }
+
+        const result = await mmgisAPI.getMapScreenshot()
+
+        expect(capture).toHaveBeenCalledTimes(1)
+        expect(result).toBe(screenshot)
+    })
+
+    test('rejects when no engine is active', async () => {
+        L_.Map_ = { engine: null }
+        await expect(mmgisAPI.getMapScreenshot()).rejects.toThrow(
+            /no active map engine/
+        )
+    })
+
+    test('rejects when the engine has no captureScreenshot method', async () => {
+        L_.Map_ = { engine: {} }
+        await expect(mmgisAPI.getMapScreenshot()).rejects.toThrow(
+            /no active map engine/
+        )
+    })
+
+    // The engine does synchronous DOM work before its promise exists (e.g.
+    // Leaflet's chrome hiding); a sync throw must surface as a rejection, not
+    // an exception escaping the promise-returning API.
+    test('converts a synchronous engine throw into a rejection', async () => {
+        L_.Map_ = {
+            engine: {
+                captureScreenshot: () => {
+                    throw new Error('boom before promise')
+                },
+            },
+        }
+        await expect(mmgisAPI.getMapScreenshot()).rejects.toThrow(
+            /boom before promise/
+        )
+    })
+})
diff --git a/tests/unit/mmgisApiViewState.spec.js b/tests/unit/mmgisApiViewState.spec.js
new file mode 100644
index 000000000..f143408cb
--- /dev/null
+++ b/tests/unit/mmgisApiViewState.spec.js
@@ -0,0 +1,75 @@
+import { test, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// Viewer_ pulls in Photosphere/ModelViewer/PDFViewer, which are JSX written in
+// .js files that vite's import-analysis can't parse. Nothing in this test needs
+// the real viewers, so stub the aggregator to keep the mmgisAPI import chain
+// parseable in the jsdom test env.
+vi.mock('../../src/essence/Basics/Viewer_/Viewer_', () => ({ default: {} }))
+
+import { mmgisAPI } from '../../src/essence/mmgisAPI/mmgisAPI'
+import L_ from '../../src/essence/Basics/Layers_/Layers_'
+
+// Issue #143 - readiness guards on the public share-link surface, and the
+// getViewState() metadata plugins use for provenance-rich export filenames.
+// L_ is a shared singleton, so we drive its fields directly and restore.
+
+const TOUCHED = ['Map_', 'configData', 'TimeControl_']
+
+test.describe('mmgisAPI.writeCoordinateURL readiness guard (issue #143)', () => {
+    let saved
+    beforeEach(() => {
+        saved = {}
+        TOUCHED.forEach((k) => (saved[k] = L_[k]))
+    })
+    afterEach(() => {
+        TOUCHED.forEach((k) => (L_[k] = saved[k]))
+        mmgisAPI.map = null
+    })
+
+    test('returns null before mission finalization instead of throwing', () => {
+        // Before fina() runs, mmgisAPI.map is unset and QueryURL's
+        // dereferences (L_.Viewer_, L_.Map_.map, ...) would TypeError.
+        mmgisAPI.map = null
+        expect(mmgisAPI.writeCoordinateURL()).toBeNull()
+    })
+})
+
+test.describe('mmgisAPI.getViewState (issue #143)', () => {
+    let saved
+    beforeEach(() => {
+        saved = {}
+        TOUCHED.forEach((k) => (saved[k] = L_[k]))
+    })
+    afterEach(() => {
+        TOUCHED.forEach((k) => (L_[k] = saved[k]))
+    })
+
+    test('returns all-null fields when nothing has loaded', () => {
+        L_.Map_ = null
+        L_.configData = null
+        L_.TimeControl_ = null
+        expect(mmgisAPI.getViewState()).toEqual({
+            missionName: null,
+            time: null,
+            center: null,
+            zoom: null,
+        })
+    })
+
+    test('reports mission, time, center, and zoom once loaded', () => {
+        L_.Map_ = {
+            map: {
+                getCenter: () => ({ lat: 4.5, lng: 137.4 }),
+                getZoom: () => 7,
+            },
+        }
+        L_.configData = { msv: { mission: 'MSL' } }
+        L_.TimeControl_ = { currentTime: '2026-07-01T12:00:00Z' }
+        expect(mmgisAPI.getViewState()).toEqual({
+            missionName: 'MSL',
+            time: '2026-07-01T12:00:00Z',
+            center: { lat: 4.5, lng: 137.4 },
+            zoom: 7,
+        })
+    })
+})
diff --git a/tests/unit/shareScreenshotApi.spec.js b/tests/unit/shareScreenshotApi.spec.js
new file mode 100644
index 000000000..fd478153e
--- /dev/null
+++ b/tests/unit/shareScreenshotApi.spec.js
@@ -0,0 +1,229 @@
+import { test, expect, vi } from 'vitest'
+
+// Issue #143 - expose share-link and map-screenshot as first-class plugin API.
+//
+// LeafletScreenshot.getMapScreenshot() drives the live DOM (jQuery) and
+// rasterizes with html2canvas, neither of which exists in this Node test
+// context — so both module imports are replaced with configurable fakes via
+// vi.mock (no production injection seam needed). Each test assigns the fake
+// implementations through the hoisted `mocks` holder before calling.
+
+const mocks = vi.hoisted(() => ({ jquery: null, html2canvas: null }))
+vi.mock('jquery', () => ({ default: (...args) => mocks.jquery(...args) }))
+vi.mock('html2canvas', () => ({
+    default: (...args) => mocks.html2canvas(...args),
+}))
+
+import { getMapScreenshot } from '../../src/essence/Basics/MapEngines/Adapters/LeafletScreenshot.js'
+
+// A fake jQuery that records every .css(prop, value) setter call (keyed by the
+// selector it was invoked on) and answers .css(prop) getters with a known value.
+function makeMockJQuery(getterValue) {
+    const cssSets = [] // { selector, prop, value }
+    const triggered = [] // { selector, event }
+
+    function makeNode(selector) {
+        return {
+            // A matched selector reports one element; the code uses .length to
+            // detect whether the time UI was active before the capture.
+            length: 1,
+            css(prop, value) {
+                if (value === undefined) return getterValue // getter
+                cssSets.push({ selector, prop, value })
+                return this
+            },
+            children() {
+                // No children in the fake DOM; the z-index reorder loop no-ops.
+                return { each() { return this } }
+            },
+            trigger(event) {
+                triggered.push({ selector, event })
+                return this
+            },
+        }
+    }
+
+    function jquery(selector) {
+        return makeNode(selector)
+    }
+    jquery._cssSets = cssSets
+    jquery._triggered = triggered
+    return jquery
+}
+
+function makePngBlob(content = 'png') {
+    return new Blob([content], { type: 'image/png' })
+}
+
+function makeMockHtml2canvas(blob = makePngBlob()) {
+    const calls = [] // { element, options }
+    function html2canvas(element, options) {
+        calls.push({ element, options })
+        return Promise.resolve({
+            width: element.offsetWidth,
+            height: element.offsetHeight,
+            toBlob: (callback, type) => {
+                expect(type).toBe('image/png')
+                callback(blob)
+            },
+        })
+    }
+    html2canvas._calls = calls
+    return html2canvas
+}
+
+function setupGlobalDom() {
+    global.window = global.window || {}
+    global.window.scrollX = 0
+    global.window.scrollY = 0
+    global.document = {
+        getElementById: (id) =>
+            id === 'mapScreen' ? { offsetWidth: 1024, offsetHeight: 768 } : null,
+        body: { querySelectorAll: () => [] },
+        createElement: () => ({
+            appendChild() {},
+            removeChild() {},
+            setAttribute() {},
+            removeAttribute() {},
+        }),
+    }
+}
+
+test.describe('LeafletScreenshot.getMapScreenshot - behavior', () => {
+    test.beforeEach(() => {
+        setupGlobalDom()
+        mocks.jquery = makeMockJQuery('5px')
+        mocks.html2canvas = makeMockHtml2canvas()
+    })
+
+    test('resolves to a PNG Blob screenshot result produced by html2canvas', async () => {
+        const blob = makePngBlob('leaflet')
+        mocks.html2canvas = makeMockHtml2canvas(blob)
+
+        const result = await getMapScreenshot()
+
+        expect(result).toEqual({
+            blob,
+            mimeType: 'image/png',
+            extension: 'png',
+            width: 1024,
+            height: 768,
+        })
+    })
+
+    test('rejects when canvas.toBlob returns null', async () => {
+        mocks.html2canvas = (element, options) =>
+            Promise.resolve({
+                width: element.offsetWidth,
+                height: element.offsetHeight,
+                toBlob: (callback) => callback(null),
+            })
+
+        await expect(getMapScreenshot()).rejects.toThrow(/toBlob returned null/)
+    })
+
+    test('invokes html2canvas once on #mapScreen with an onclone option', async () => {
+        const html2canvas = mocks.html2canvas
+
+        await getMapScreenshot()
+
+        expect(html2canvas._calls.length).toBe(1)
+        const { element, options } = html2canvas._calls[0]
+        expect(element.offsetWidth).toBe(1024)
+        expect(options.windowWidth).toBe(1024)
+        expect(options.windowHeight).toBe(768)
+        // The onclone SVG/z-index fixups are mandatory for a correct capture.
+        expect(typeof options.onclone).toBe('function')
+    })
+
+    test('hides UI chrome for the capture and restores it afterwards', async () => {
+        const jquery = mocks.jquery
+
+        await getMapScreenshot()
+
+        const displayFor = (selector) =>
+            jquery._cssSets
+                .filter((c) => c.selector === selector && c.prop === 'display')
+                .map((c) => c.value)
+
+        // Each chrome element is hidden, then restored (visible) again.
+        expect(displayFor('.leaflet-control-zoom')).toEqual(['none', 'block'])
+        expect(displayFor('.leaflet-control-scalefactor')).toEqual([
+            'none',
+            'flex',
+        ])
+        expect(displayFor('#mmgis-map-compass')).toEqual(['none', 'block'])
+    })
+
+    test('restores #mapToolBar bottom to its saved value, not a string literal', async () => {
+        // Regression guard: the restore must pass the captured variable, not the
+        // literal 'savedMapToolBarBottom'. Saved value here is '5px'.
+        const jquery = mocks.jquery
+
+        await getMapScreenshot()
+
+        const bottomValues = jquery._cssSets
+            .filter((c) => c.selector === '#mapToolBar' && c.prop === 'bottom')
+            .map((c) => c.value)
+
+        expect(bottomValues).toEqual(['0px', '5px'])
+        expect(bottomValues).not.toContain('savedMapToolBarBottom')
+    })
+
+    test('collapses the time UI for the capture and reopens it afterwards', async () => {
+        // Regression guard: the time UI is toggled off (via the .active
+        // selector) before the shot and must be toggled back on (via the plain
+        // selector, since the click cleared .active) afterwards. Previously the
+        // restore was missing, leaving the time UI collapsed.
+        const jquery = mocks.jquery
+
+        await getMapScreenshot()
+
+        const timeToggleEvents = jquery._triggered.filter((t) =>
+            t.selector.startsWith('#toggleTimeUI')
+        )
+        expect(timeToggleEvents).toEqual([
+            { selector: '#toggleTimeUI.active', event: 'click' },
+            { selector: '#toggleTimeUI', event: 'click' },
+        ])
+    })
+
+    test('onclone applies the styles snapshotted before the UI restore', async () => {
+        // Regression guard for the restore/onclone race: the clone fixups must
+        // use the tile styles captured at kickoff (post-normalization), not
+        // re-read the live DOM (already restored when onclone fires). We
+        // simulate: live tiles report style A at kickoff, then mutate to style
+        // B before onclone runs — the clone must receive A.
+        const liveTile = {
+            getAttribute: () => 'z-index: 1',
+            setAttribute() {},
+        }
+        global.document.body.querySelectorAll = (sel) =>
+            sel.includes('tile') ? [liveTile] : []
+
+        let cloneApplied = []
+        const cloneTile = {
+            setAttribute: (name, value) => cloneApplied.push(value),
+            getAttribute: () => null,
+        }
+        mocks.html2canvas = (element, options) => {
+            // Live DOM "restores" (mutates) before onclone fires.
+            liveTile.getAttribute = () => 'z-index: 999'
+            options.onclone({
+                body: {
+                    querySelectorAll: (sel) =>
+                        sel.includes('tile') ? [cloneTile] : [],
+                },
+            })
+            return Promise.resolve({
+                width: element.offsetWidth,
+                height: element.offsetHeight,
+                toBlob: (callback) => callback(makePngBlob()),
+            })
+        }
+
+        await getMapScreenshot()
+
+        expect(cloneApplied).toEqual(['z-index: 1'])
+    })
+})
diff --git a/tests/unit/writeCoordinateURL.spec.js b/tests/unit/writeCoordinateURL.spec.js
new file mode 100644
index 000000000..335bbbcd4
--- /dev/null
+++ b/tests/unit/writeCoordinateURL.spec.js
@@ -0,0 +1,155 @@
+import { test, expect, vi, beforeEach, afterEach } from 'vitest'
+
+// Viewer_ pulls in Photosphere/ModelViewer/PDFViewer, which are JSX written in
+// .js files that vite's import-analysis can't parse. Nothing here needs the real
+// viewers, so stub the aggregator to keep the QueryURL import chain parseable in
+// the jsdom test env.
+vi.mock('../../src/essence/Basics/Viewer_/Viewer_', () => ({ default: {} }))
+vi.mock('../../src/pre/calls', () => ({
+    default: {
+        api: vi.fn(),
+    },
+}))
+vi.mock('../../src/pre/capabilities', () => ({
+    isStaticBuild: vi.fn(() => false),
+}))
+
+import QueryURL from '../../src/essence/Ancillary/QueryURL'
+import L_ from '../../src/essence/Basics/Layers_/Layers_'
+import T_ from '../../src/essence/Basics/ToolController_/ToolController_'
+import calls from '../../src/pre/calls'
+import { isStaticBuild } from '../../src/pre/capabilities'
+
+// Issue #143 - writeCoordinateURL() is the canonical share-link method: it must
+// return the full view URL synchronously (a string, no backend call), and it
+// must not throw in the modern layout, where UserInterface_.getPanelPercents()
+// does not exist (classic/mobile only). The guard falls back to a map-only
+// pane split there.
+
+// The set of L_ / T_ properties writeCoordinateURL touches. We stub the minimal
+// surface so every branch reaches the return, then snapshot/restore around each
+// test since L_ and T_ are shared singletons.
+const TOUCHED = [
+    'Viewer_',
+    'Map_',
+    'Globe_',
+    'mission',
+    'site',
+    'UserInterface_',
+    'layers',
+    'lastActiveFeature',
+    'configData',
+]
+
+let saved
+let savedGetToolsUrl
+
+beforeEach(() => {
+    vi.mocked(calls.api).mockReset()
+    vi.mocked(isStaticBuild).mockReturnValue(false)
+
+    saved = {}
+    for (const key of TOUCHED) saved[key] = L_[key]
+    savedGetToolsUrl = T_.getToolsUrl
+
+    L_.Viewer_ = { getLocation: () => false, getLastImageId: () => false }
+    L_.Map_ = {
+        map: {
+            getCenter: () => ({ lng: -122.5, lat: 37.8 }),
+            getZoom: () => 6,
+        },
+    }
+    L_.Globe_ = { litho: { getCenter: () => null, getCameras: () => null } }
+    L_.mission = 'TestMission'
+    L_.site = ''
+    L_.layers = { on: {}, data: {}, opacity: {} }
+    L_.lastActiveFeature = { layerName: null }
+    L_.configData = { time: { enabled: false } }
+    T_.getToolsUrl = () => false
+})
+
+afterEach(() => {
+    for (const key of TOUCHED) L_[key] = saved[key]
+    T_.getToolsUrl = savedGetToolsUrl
+})
+
+test.describe('QueryURL.writeCoordinateURL (issue #143)', () => {
+    test('returns the full view URL synchronously as a string', () => {
+        L_.UserInterface_ = {
+            getPanelPercents: () => ({ viewer: 10, map: 70, globe: 20 }),
+        }
+
+        const url = QueryURL.writeCoordinateURL()
+
+        // Synchronous string, not a Promise.
+        expect(typeof url).toBe('string')
+        expect(url).toContain('mission=TestMission')
+        expect(url).toContain('mapLon=-122.5')
+        expect(url).toContain('mapLat=37.8')
+        expect(url).toContain('mapZoom=6')
+        expect(url).toContain('panePercents=10,70,20')
+    })
+
+    test('does not throw in the modern layout and falls back to a map-only split', () => {
+        // Modern layout: no getPanelPercents on UserInterface_.
+        L_.UserInterface_ = {}
+
+        let url
+        expect(() => {
+            url = QueryURL.writeCoordinateURL()
+        }).not.toThrow()
+        expect(url).toContain('panePercents=0,100,0')
+    })
+})
+
+test.describe('QueryURL.getShareURL (issue #143)', () => {
+    test('returns the long URL without shortening in static builds', () => {
+        vi.mocked(isStaticBuild).mockReturnValue(true)
+        L_.UserInterface_ = {}
+
+        const callback = vi.fn()
+
+        QueryURL.getShareURL(callback)
+
+        expect(calls.api).not.toHaveBeenCalled()
+        expect(callback).toHaveBeenCalledWith(
+            expect.stringContaining('mission=TestMission')
+        )
+        expect(callback.mock.calls[0][0]).toContain('panePercents=0,100,0')
+    })
+
+    test('returns a short URL when the full-mode shortener succeeds', () => {
+        L_.UserInterface_ = {}
+        vi.mocked(calls.api).mockImplementation((call, data, success) => {
+            success({ body: { url: 'abc12' } })
+        })
+        const callback = vi.fn()
+
+        QueryURL.getShareURL(callback)
+
+        expect(calls.api).toHaveBeenCalledWith(
+            'shortener_shorten',
+            { url: expect.stringContaining('?mission=TestMission') },
+            expect.any(Function),
+            expect.any(Function)
+        )
+        expect(callback).toHaveBeenCalledWith(
+            'http://localhost:3000/?s=abc12'
+        )
+    })
+
+    test('falls back to the long URL when shortening fails', () => {
+        L_.UserInterface_ = {}
+        vi.mocked(calls.api).mockImplementation((call, data, success, error) => {
+            error()
+        })
+        const callback = vi.fn()
+
+        QueryURL.getShareURL(callback)
+
+        expect(callback).toHaveBeenCalledWith(
+            expect.stringContaining('mission=TestMission')
+        )
+        expect(callback.mock.calls[0][0]).not.toContain('?s=')
+    })
+})