arcane-os 0.81.0 → 0.83.0

package/docs/reference/native-app-control.md

@@ -0,0 +1,206 @@
+# Native application control
+
+`connectAppControl` from `arcane-os/core/app-control` connects to one explicitly
+selected running application window. The Windows WebView2 host provides document
+inspection, a PNG of its rendered viewport, and targeted DOM actions through its
+own local named pipe. The application keeps its existing Core child, profile,
+origin and window lifecycle. These operations do not activate the desktop window
+or send global keyboard or pointer input.
+
+The Node client uses the SDK's existing `arcane/1` framing and local pipe/socket
+transport on Windows, Linux and macOS. The native window adapter described here
+is Windows WebView2; macOS, Linux and Android hosts do not yet expose these
+operations. An installed generic browser tool does not automatically discover
+this endpoint. A caller must use this public client or CLI explicitly.
+
+## Select the running instance
+
+Add an explicit endpoint to the application's existing native launch context:
+
+```json
+{
+  "native": {
+    "launchContext": {
+      "appControl": {
+        "endpoint": "\\\\.\\pipe\\arcane-pm-control"
+      }
+    }
+  }
+}
+```
+
+The same `appControl` record can be supplied in the launch JSON already selected
+by `--arcane-launch-config`. That record is merged by the existing launcher; it
+does not select a different profile or Core topology. Omission starts the usual
+application without a control listener. Each simultaneous application instance
+needs its own endpoint. An occupied endpoint reports the actual startup failure;
+the host does not silently attach to another window or choose another name.
+
+Use a matching published Windows host asset when assembling the application.
+The host producer generates `arcane-app-control.js` from the canonical standalone
+DOM operation function and includes it beside `Arcane.exe`. Direct C# composition
+uses `ArcaneHostOptions.ApplicationId`, `AppControlEndpoint`, and
+`AppControlSource` with the same generated source. Ordinary composition leaves
+the two control options unset.
+
+## Public client
+
+```js
+import {connectAppControl} from 'arcane-os/core/app-control';
+
+const app = await connectAppControl({
+    endpoint: String.raw`\\.\pipe\arcane-pm-control`
+});
+try {
+    const page = await app.inspect();
+    await app.act({
+        documentGeneration: page.documentGeneration,
+        selector: 'a[data-route="connections"]',
+        action: 'click'
+    });
+    const contents = await app.inspect({selector: '#pm-content'});
+    console.log(contents);
+} finally {
+    await app.close();
+}
+```
+
+This example selects an existing navigation link. Its returned action result
+describes the immediate DOM operation. Inspect the resulting page to establish
+the application outcome; a click alone does not establish an asynchronous save,
+connection or other business result.
+
+| Member | Contract |
+| --- | --- |
+| `connectAppControl({endpoint, signal?, onError?})` | Connect once to the explicit running host. It never launches an app, creates Core, changes a profile or reconnects automatically. |
+| `status(options?)` | Returns app identity, platform/host, current URL, document generation, readiness, window title/state/client dimensions and available operations. Readiness describes the document, not models or application services. |
+| `inspect(parameters={}, options?)` | Optional `shadowPath` selects an open shadow root. Optional CSS `selector` selects zero or more elements within the selected root; omission selects the whole root. Optional `documentGeneration` selects the expected document. Returns complete HTML/text, live control state and DOM-derived role/name hints. |
+| `capture(parameters={}, options?)` | Returns `{mimeType:'image/png', data, documentGeneration, url}`. `data` contains the complete base64 PNG. Optional `documentGeneration` selects the expected document. |
+| `act(parameters, options?)` | Requires `documentGeneration`, one unambiguous CSS `selector` within the root selected by optional `shadowPath`, and the action fields below. |
+| `close()` | Closes this caller's connection and cancels its pending requests. It never closes the app or Core. Returns the connection's completion promise. |
+| `closed` | Connection lifetime promise; actual transport failures remain observable. |
+| `endpoint` | The caller-selected local endpoint. |
+
+Each operation's separate `options` uses the existing Core client request
+contract, including `signal` and `timeoutMs`. Connection cancellation closes only
+that connection. Cancellation before UI dispatch prevents execution. Once a
+script or capture has been dispatched, cancellation cannot reverse its effects;
+the host still observes its completion. A disconnected caller's completed result
+is retained in the host diagnostics instead of being represented as delivered.
+
+## Document operations
+
+Inspection defaults to the top-level light DOM. Its result contains `scope`, `title`,
+`readyState`, `doctype`, `roots`, `controls`, `frames`, `shadowHosts`,
+`activeElement`, `scrollingElement`, `selection`, `documentGeneration`, and
+`url`. Each root retains its complete `html` and `text`; controls retain their
+attributes and current form, selection, disabled, scrolling and related state.
+Generated CSS selectors are useful for the inspected document; a later DOM edit
+can change their meaning. Application-authored stable selectors are preferable
+when available. Component replacement or mutation can make a selector stale
+without changing the native document generation.
+
+### Open shadow roots
+
+`inspect` and `act` accept `shadowPath`, an ordered array of CSS host selectors.
+The first selector resolves inside the top-level document; each later selector
+resolves inside the preceding host's open shadow root. Every host selector must
+match exactly one element. The operation's `selector` then resolves only inside
+the final root. An omitted or empty `shadowPath` retains the ordinary light-DOM
+scope. Selecting a root never recursively enters its nested shadow roots.
+
+```js
+const shadowPath = ['#appearance-panel', 'theme-switcher'];
+const panel = await app.inspect({shadowPath});
+await app.act({
+    documentGeneration: panel.documentGeneration,
+    shadowPath,
+    selector: 'button[data-theme="dark"]',
+    action: 'click'
+});
+```
+
+Shadow inspection returns `scope:'open-shadow-root'` and the selected
+`shadowPath`. Its element selectors are local to that root. With no `selector`,
+`roots` contains one complete root record with `selector:null`, its full
+`innerHTML` as `html`, its full `textContent` as `text`, and `state:null`; a
+ShadowRoot itself is not an element or an action target. With a selector, roots
+retain their element HTML and state. Controls, frames and open-shadow hosts are
+described within this selected tree. Each `shadowHosts` descriptor retains its
+local `selector` and `mode`, and adds the full `shadowPath` needed to inspect
+that host's shadow root, including nested hosts. Pass that path to the next
+inspection; pair selectors from its result with that same path for actions.
+
+`activeElement` comes from the selected root. `scrollingElement` is `null` for a
+shadow-root scope because the root has no document scrolling element; scroll
+actions still target elements. `selection.text`, `title`, `readyState`, `doctype`
+and native URL/generation remain document-level information. Role/name label
+references resolve within the element's own tree. Inspection follows the DOM
+tree, not the composed rendering tree: slot-assigned light-DOM nodes remain in
+their own containing DOM tree and are not duplicated inside the selected shadow
+root.
+
+A missing or ambiguous host produces document error `ARCANE_APP_CONTROL_TARGET_COUNT`
+with the complete path, zero-based `index`, `selector` and match count. Invalid
+path or CSS input reports its actual error before any action. A host without an
+accessible open root produces document error `ARCANE_APP_CONTROL_UNSUPPORTED`
+with the path and failing step. The Windows client rejects these document failures
+with top-level `error.code === 'ARCANE_APP_CONTROL_FAILED'`; the original document
+error, including its `code` and `details`, is available at
+`error.data.find(entry => entry.key === 'documentError').value`.
+Closed roots cannot be discovered, entered, or distinguished from
+absent roots through this API. No closed-root interception is installed.
+Shadow actions add the selected `shadowPath` to their result and retain the
+actual target state after dispatch, including disconnection by the action.
+
+Role/name hints are derived from DOM attributes and labels, not a native
+accessibility-tree computation. Frame documents and unselected shadow-root
+contents are outside the selected scope. Frame elements and open-shadow hosts
+are described; closed shadow roots cannot be discovered. Capture is the current rendered
+viewport, not an offscreen full-document rendering. Covered and minimized-window
+capture behavior requires execution evidence in the selected environment.
+
+| Action | Parameters and immediate behavior |
+| --- | --- |
+| `click` | Calls the uniquely selected element's DOM `click()` method. |
+| `fill` | Exact string `value` replaces an input, textarea or contenteditable value; input/change events are dispatched. Read-only, disabled and non-text input controls report their actual unsupported state. |
+| `select` | Exact `value` string or `values` string array selects native `<select>` options and dispatches input/change. Multiple values require a multiple-select control. |
+| `scroll` | Absolute numeric `left`, `top`, or both in CSS pixels; the omitted axis retains its position. Returns the resulting scroll state, including browser clamping. |
+
+DOM actions use programmatic, untrusted events. They do not supply physical user
+activation for browser features that require it. Results describe the actual
+immediate state, including browser value sanitization; input is not silently
+rewritten by the SDK.
+
+The host publishes a new generation when an actual replacement document becomes
+ready. A creation-time document marker is also checked inside the executing
+script so a queued action cannot run against a successor page. During navigation,
+operations report that the document is not ready. A change during completion
+reports the actual result with that failure; actions are never retried. These
+markers are transient document lifecycle state and are not written to saved data.
+
+## CLI
+
+```powershell
+arcane app-control status --endpoint '\\.\pipe\arcane-pm-control'
+arcane app-control inspect --endpoint '\\.\pipe\arcane-pm-control' --selector '#pm-content'
+arcane app-control inspect --endpoint '\\.\pipe\arcane-pm-control' --request '.arcane\inspection.json'
+arcane app-control capture --endpoint '\\.\pipe\arcane-pm-control' --output '.arcane\view.png'
+arcane app-control act --endpoint '\\.\pipe\arcane-pm-control' --request '.arcane\action.json'
+```
+
+The action file is the complete action parameter object, including the actual
+`documentGeneration` returned by the preceding status or inspection. Inspection
+also accepts `--request` for a complete parameter object, such as
+`{"shadowPath":["#appearance-panel","theme-switcher"]}` or the same object with
+`selector` and `documentGeneration`. Inspection's `--request` and `--selector`
+options are mutually exclusive. The CLI reads the selected file completely.
+Paths are relative to the current directory. Capture
+writes the PNG to the explicitly selected file and prints its metadata. The other
+operations print complete JSON. `app-control --help` describes this command's
+options; other Arcane commands retain their existing global output-format option.
+
+Pipe startup, framing, document, image and output-file errors remain observable.
+Host shutdown stops new control work and observes accepted operations alongside
+the existing Core drain. It does not wait for desktop input or leave an
+independent controller process running.

package/docs/reference/runtime-components.md

@@ -372,6 +372,26 @@ reach developer diagnostics and a concise recovery status stays outside the
 transcript. Destruction cancels pending preparation, while an already requested
 print retains its snapshot through `afterprint`.
 
+Markdown images with local `arcane-media:` references saved through
+[`MarkdownMedia`](runtime-modules.md#markdownmediajs) display automatically in
+new messages, live response chunks, final responses, and restored history.
+Chat resolves references through the existing application-scoped DBOPFS owner
+while preserving the complete original Markdown, model payloads, saved history,
+image descriptions, and ordinary image URLs. Text appears immediately; local
+image reads and decoding proceed independently without delaying streaming or
+session readiness. Failed images retain complete developer diagnostics and show
+a concise message beside that card; successful sibling images remain visible.
+
+Each rendered card owns its display URLs. Re-rendering, history replacement,
+transient-message removal, and destruction cancel obsolete display work and
+release those URLs without deleting stored images. Back/Forward Cache retains
+the existing component lifecycle. Explicit `print()` awaits the current images;
+native Print reports images that are still loading or failed instead of claiming
+they are ready. A requested print snapshot retains its image URLs across later
+message changes or component destruction until `afterprint` releases them.
+Applications continue to own image-record names, associations, and cleanup;
+Chat introduces no renderer callback or additional storage API.
+
 Before any session binding begins, callback-mode `sessionStatus` follows the
 selected sticky LLM role and the existing application-owned `modelName` label
 (or the selected model ID). Assigning `modelName` refreshes that status even

package/docs/reference/sdk-api.md

@@ -58,6 +58,7 @@ runtime layouts.
 | `arcane-os/core/development` | App-service composition and document-owned Core transport during source development, independently of local AI. |
 | `arcane-os/core/stdio` | Framed Node stdio transport with graceful runtime drain. |
 | `arcane-os/core/host` | Node-only reusable Core host lifecycle, app-selected native launch defaults and shared native location resolution. |
+| `arcane-os/core/app-control` | Explicit connection to an existing native window for background document inspection, capture and DOM actions. |
 | `arcane-os/codex/app-server` | Explicit native Codex App Server session, complete live turns, server requests and recovery. |
 | `arcane-os/mcp/stdio` | Node MCP STDIO server for app-owned tools and static resources. |
 | `arcane-os/core/repositories` | Native persistent ArcaneData paths, connected working repositories and scoped non-secret Git identity configuration. |
@@ -428,6 +429,7 @@ The remaining data-only subpaths are eight JSON Schemas and package metadata.
 | `startCoreHost()` | function | `arcane-os/core/host` | Native Core host composition | Node with readable input and writable output streams |
 | `startSharedCoreHost()` | function | `arcane-os/core/host` | Shared Core host | Node local IPC on Windows, Linux and macOS |
 | `connectSharedCoreHost()` | function | `arcane-os/core/host` | Shared Core host | Node local IPC and optional explicit headless startup |
+| `connectAppControl()` | function | `arcane-os/core/app-control` | Native application control | Node local IPC; current window adapter is Windows WebView2 |
 | `runSharedCoreHost()` | function | `arcane-os/core/host` | Shared Core host | Node headless entry and optional parent startup IPC |
 | `startSharedCoreBridge()` | function | `arcane-os/core/host` | Shared Core host | Node readable/writable streams and local IPC |
 | `readCoreLaunchContext()` | function | `arcane-os/core/host` | Native Core host composition | Node; combines packaged defaults, host state and explicitly selected launch JSON |
@@ -8886,6 +8888,34 @@ try {
 }
 ```
 
+## connectAppControl()
+
+```text
+connectAppControl({endpoint,signal,onError}={})
+```
+
+Connects once to the explicit running native window and resolves
+`{endpoint,closed,status,inspect,capture,act,close}`. The Windows host selects its
+own listener through `native.launchContext.appControl.endpoint` and preserves the
+existing Core child, origin, profile and application lifetime. The client uses
+portable Node local IPC; other native host adapters do not yet implement these
+document operations. No application is launched, no desktop window is activated,
+and no automatic reconnect or action retry occurs.
+
+`status(options)` reports current app/window/document readiness.
+`inspect(parameters={},options)` returns complete selected DOM HTML/text
+and live control state. Inspection and actions accept optional `shadowPath`, an
+ordered array of unique CSS host selectors through open shadow roots; their
+`selector` resolves inside the final root. Omission retains top-level light DOM.
+Closed roots remain unavailable. `capture(parameters={},options)` returns a full base64 PNG
+of the rendered viewport. `act(parameters,options)` requires a returned
+`documentGeneration`, one CSS selector, and `click`, `fill`, `select` or `scroll`
+fields. Options preserve the Core client signal/timeout contract. `close()`
+cancels this connection's requests and returns `closed`, without closing the app.
+Document changes and actual errors remain observable; a dispatched action is
+not reversed by later cancellation. Full parameter/result, CLI and platform
+contracts are in [native application control](native-app-control.md).
+
 ## runSharedCoreHost()
 
 Accepts the same options as `startSharedCoreHost(options)` and adds the headless

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "arcane-os",
-  "version": "0.81.0",
+  "version": "0.83.0",
   "description": "Arcane OS JavaScript SDK, project-local CLI, browser runtime, and repository-portable application packager.",
   "type": "module",
   "main": "./src/index.mjs",
@@ -62,6 +62,7 @@
     "./core/development": "./src/core/development.mjs",
     "./core/stdio": "./src/core/stdio.mjs",
     "./core/host": "./src/core/host.mjs",
+    "./core/app-control": "./src/core/app-control.mjs",
     "./codex/app-server": "./src/codex/app-server.mjs",
     "./mcp/stdio": "./src/mcp/stdio-server.mjs",
     "./core/repositories": "./src/core/repositories.mjs",

package/runtime/arcane/components/chat.html

@@ -886,6 +886,7 @@
     const aiActivationButton=shadowRoot.querySelector('#ai_activation_button');
     const [
         {default:MD},
+        {hydrateMarkdownMedia},
         {default:FileEntity},
         {ConversationSubmissionBarrier,requireConversationTimeboxDelivery},
         {requestAIRuntimeIntent,subscribeAIRuntimeState},
@@ -893,6 +894,7 @@
         {getBrowserDeviceClass}
     ]=await Promise.all([
         import('../modules/MD.js'),
+        import('../modules/MarkdownMedia.js'),
         import('../entities/File.js'),
         import('../modules/ConversationTimebox.js'),
         import('../modules/AIRuntimeState.js'),
@@ -946,15 +948,19 @@
     let destroyed=false;
     let recognitionDraft=null;
     let writingRecognitionDraft=false;
+    const transcriptMedia=new Map();
+    let printMediaRetains=null;
     const printViewPromise=import('../modules/PrintView.js').then(
         function registerChatPrint({createPrintView}){
             if(destroyed) return null;
             return createPrintView({
                 host,
-                content:function chatPrintContent(){return chatOutput;},
+                content:renderedChatPrintContent,
                 title:function chatPrintTitle(){return host.printTitle||'Conversation';},
                 active:function chatPrintActive(){return !destroyed&&chatOutput.children.length>0;},
                 signal:aiRuntimeStateAbortController.signal,
+                retain:retainChatPrintMedia,
+                prepare:prepareChatPrintMedia,
                 onError:reportChatPrintFailure
             });
         }
@@ -1190,6 +1196,7 @@
             for(const item of record.removedNodes) {
                 if(item.localName === 'li' && item.parentElement !== chatOutput) {
                     transcriptResizeObserver?.unobserve(item);
+                    releaseTranscriptMessageMedia(item);
                 }
             }
             for(const item of record.addedNodes) {
@@ -1427,14 +1434,72 @@
         return entry;
     }
 
+    function renderTranscriptMarkdown(target,content){
+        if(destroyed) return null;
+        const template=target.ownerDocument.createElement('template');
+        template.innerHTML=new MD(content).rendered;
+        const pending=[...template.content.querySelectorAll('img')].some(
+            function localChatImage(image){
+                return image.getAttribute('src')?.startsWith('arcane-media:');
+            }
+        );
+        // Remove local-reference src values while detached; text renders now,
+        // and the shared media owner observes independent storage and decoding.
+        const handle=hydrateMarkdownMedia(template.content,{
+            signal:aiRuntimeStateAbortController.signal
+        });
+        releaseTranscriptMarkdown(target);
+        const media={handle,pending,error:null,status:null,ready:null};
+        transcriptMedia.set(target,media);
+        if(printMediaRetains){
+            printMediaRetains.add(handle.retain());
+        }
+        target.raw=content;
+        target.replaceChildren(template.content);
+        media.ready=handle.ready.then(function transcriptImagesReady(){
+            media.pending=false;
+        },function transcriptImagesFailed(error){
+            media.pending=false;
+            media.error=error;
+            if(destroyed||transcriptMedia.get(target)!==media) return;
+            arcaneLogging.error('Unable to display saved Chat images.',error);
+            const status=target.ownerDocument.createElement('p');
+            status.className='message_media_status';
+            status.setAttribute('role','status');
+            status.textContent='Some saved images could not be displayed.';
+            media.status=status;
+            target.after(status);
+            scrollTranscriptToBottom();
+        });
+        return media;
+    }
+
+    function releaseTranscriptMarkdown(target){
+        const media=transcriptMedia.get(target);
+        if(!media) return;
+        transcriptMedia.delete(target);
+        media.status?.remove();
+        media.handle.destroy();
+    }
+
+    function releaseTranscriptMessageMedia(item){
+        const markdown=item?.querySelector('.markdown');
+        if(markdown) releaseTranscriptMarkdown(markdown);
+    }
+
+    function removeTranscriptMessage(item){
+        if(!item) return;
+        releaseTranscriptMessageMedia(item);
+        item.remove();
+    }
+
     function setTranscriptMessageContent(item,content,timestamp){
         if(!is.string(content)){
             throw new TypeError('Chat session message content must be a string.');
         }
         item.querySelector('.thinking')?.remove();
         const markdown=item.querySelector('.markdown');
-        markdown.raw=content;
-        markdown.innerHTML=new MD(content).rendered;
+        renderTranscriptMarkdown(markdown,content);
         if(timestamp!==undefined){
             item.querySelector('.message_timestamp')?.replaceWith(
                 transcriptTime(timestamp)
@@ -1495,12 +1560,11 @@
         header.append(heading);
         const markdown=chatOutput.ownerDocument.createElement('div');
         markdown.className='markdown';
-        markdown.raw=content;
-        markdown.innerHTML=new MD(content).rendered;
         item.append(header,markdown,transcriptTime(timestamp));
         for(const call of normalizeVisibleToolCalls(toolCalls)){
             appendVisibleToolCall(item,call);
         }
+        renderTranscriptMarkdown(markdown,content);
         return item;
     }
 
@@ -1642,6 +1706,9 @@
         setPendingStructuralToolCalls(
             actionable?[...restoredPendingToolCalls.values()]:[]
         );
+        for(const item of chatOutput.children){
+            releaseTranscriptMessageMedia(item);
+        }
         chatOutput.replaceChildren(fragment);
         transcriptFollowing = true;
         transcriptScrollTop = chatOutput.scrollTop;
@@ -3034,9 +3101,7 @@
             thinkingHTML.remove();
         }
         
-        target.raw ? target.raw+=text : target.raw=text;
-
-        target.innerHTML=new MD(target.raw).rendered;
+        renderTranscriptMarkdown(target,target.raw?target.raw+text:text);
         
         scrollTranscriptToBottom();
     }
@@ -3393,8 +3458,7 @@
         message.querySelector('.thinking')?.remove();
         const markdown=message.querySelector('.markdown');
         const text=visibleErrorMessage(error,'The AI request failed.');
-        markdown.raw=text;
-        markdown.innerHTML=new MD(text).rendered;
+        renderTranscriptMarkdown(markdown,text);
         scrollTranscriptToBottom();
         return true;
     }
@@ -3421,8 +3485,8 @@
         const response=[...chatOutput.children].find(
             candidate=>candidate.id===`message-${messageId}`
         )||null;
-        response?.remove();
-        for(const request of requestMessages) request.remove();
+        removeTranscriptMessage(response);
+        for(const request of requestMessages) removeTranscriptMessage(request);
         const existing=textArea.value;
         if(existing!==text){
             textArea.value=existing
@@ -3500,7 +3564,7 @@
         function removeTransientSessionCards(){
             if(retainTurn||!transientCards.length) return;
             // The submitter supplies only nodes created for this submission.
-            for(const card of transientCards) card.remove();
+            for(const card of transientCards) removeTranscriptMessage(card);
             transientCards.length=0;
             scrollTranscriptToBottom();
         }
@@ -3675,9 +3739,9 @@
                     const response=[...chatOutput.children].find(
                         candidate=>candidate.id===`message-${messageId}`
                     )||null;
-                    response?.remove();
+                    removeTranscriptMessage(response);
                     for(const requestMessage of requestMessages){
-                        requestMessage.remove();
+                        removeTranscriptMessage(requestMessage);
                     }
                     scrollTranscriptToBottom();
                 }else if(retainTurn){
@@ -3692,7 +3756,7 @@
                 arcaneLogging.error('Arcane chat request failed.',error);
                 if(sessionRequestMessages.every(message=>message.role==='tool')){
                     for(const requestMessage of requestMessages){
-                        requestMessage.remove();
+                        removeTranscriptMessage(requestMessage);
                     }
                 }
                 if(retainTurn) renderSessionMessageFailure(messageId,error);
@@ -4136,11 +4200,64 @@
         return message;
     }
 
+    function renderedChatPrintContent(){
+        for(const media of transcriptMedia.values()){
+            if(media.pending){
+                const error=new Error('Saved images are still loading. Print again when they finish.');
+                error.code='ARCANE_MARKDOWN_MEDIA_PENDING';
+                throw error;
+            }
+            if(media.error) throw media.error;
+        }
+        return chatOutput;
+    }
+
+    function retainChatPrintMedia(){
+        renderedChatPrintContent();
+        const releases=new Set();
+        for(const media of transcriptMedia.values()){
+            releases.add(media.handle.retain());
+        }
+        printMediaRetains=releases;
+        return function releaseChatPrintMedia(){
+            if(printMediaRetains===releases){
+                printMediaRetains=null;
+            }
+            for(const release of releases) release();
+            releases.clear();
+        };
+    }
+
+    async function prepareChatPrintMedia(signal){
+        let cancel;
+        const cancelled=new Promise(function waitForChatPrintCancellation(resolve){cancel=resolve;});
+        signal?.addEventListener('abort',cancel,{once:true});
+        try{
+            while(!destroyed&&!signal?.aborted){
+                const selected=[...transcriptMedia];
+                await Promise.race([
+                    Promise.all(selected.map(function readyChatMedia([,media]){return media.ready;})),
+                    cancelled
+                ]);
+                if(destroyed||signal?.aborted) return false;
+                if(selected.length!==transcriptMedia.size||selected.some(
+                    function replacedChatMedia([target,media]){return transcriptMedia.get(target)!==media;}
+                )) continue;
+                renderedChatPrintContent();
+                return true;
+            }
+            return false;
+        }finally{
+            signal?.removeEventListener('abort',cancel);
+        }
+    }
+
     async function print(){
         if(destroyed) return false;
         try{
             const view=await printViewPromise;
-            return destroyed||!view?false:await view.print();
+            if(destroyed||!view||!await prepareChatPrintMedia()) return false;
+            return await view.print();
         }catch(error){
             reportChatPrintFailure(error);
             throw error;
@@ -4150,7 +4267,9 @@
     function reportChatPrintFailure(error){
         arcaneLogging.error('Unable to print the conversation.',error);
         if(!destroyed){
-            setSessionStatus('error','Unable to open print preview. Please try again.');
+            setSessionStatus('error',error?.code==='ARCANE_MARKDOWN_MEDIA_PENDING'
+                ?'Saved images are still loading. Print again when they finish.'
+                :'Unable to open print preview. Please try again.');
         }
     }
 
@@ -4235,6 +4354,9 @@
             ownership.abort(destroyReason);
         }
         aiRuntimeStateAbortController.abort(destroyReason);
+        for(const target of transcriptMedia.keys()){
+            releaseTranscriptMarkdown(target);
+        }
         aiActivationController.destroy();
         window.removeEventListener('pagehide',handlePageHide);
         window.removeEventListener('pageshow',handlePageShow);