@hachej/boring-ui-kit 0.4.50 → 0.4.51

package/dist/chat-react-controller.d.ts

@@ -1,5 +1,8 @@
-export type ConversationControllerState<C> = {
+export type ConversationControllerState<C> = 
+/** `controller`: created, its `connect` still running (absent before creation). Hosts that wait for `ready` can ignore it. */
+{
     readonly status: 'connecting';
+    readonly controller?: C;
 } | {
     readonly status: 'offline';
     readonly error: unknown;

package/dist/chat-react-controller.js

@@ -34,6 +34,7 @@ export function useControllerPerConversation(options) {
                         await retire();
                         return;
                     }
+                    publish({ status: 'connecting', controller: owned });
                     await connect?.(owned);
                     if (off) {
                         await retire();
@@ -43,6 +44,9 @@ export function useControllerPerConversation(options) {
                     return;
                 }
                 catch (error) {
+                    // A controller handed out while connecting is withdrawn before it is disposed, so no host holds a disposed one.
+                    if (owned)
+                        publish({ status: 'connecting' });
                     try {
                         await retire();
                     }

package/dist/chat-react-remote.d.ts

@@ -4,18 +4,32 @@ export type ChatPlacement = 'docked' | 'floating';
 /** Reports the placement of the chat showing `controller` while the caller is mounted. */
 export declare function useChatPlacement(controller: ChatController, placement: ChatPlacement): void;
 export declare function readChatPlacement(controller: ChatController | undefined): ChatPlacement | undefined;
+type RemoteActions = Partial<Pick<RemoteChat, 'answer' | 'withdraw'>>;
+/**
+ * `connecting` carries the controller as soon as it exists (D-1434, before the host's first view lands): its composer takes messages at
+ * once, shows them as the person's own and sends them, in order, once connected; the transcript appears with the first view. `actions` and
+ * `configure` wait for the connection. `ready` still means the first view landed, with the same controller; a host that waits for `ready`
+ * (or ignores `controller` while connecting) behaves as before. If connecting fails the state turns `offline` without a controller, and
+ * the messages not sent come back in the next attempt's composer.
+ */
 export type RemoteChatState = {
     readonly status: 'connecting';
     readonly conversationId: string | undefined;
+    readonly controller?: NativeChatController;
+    readonly actions?: RemoteActions;
+    readonly configure?: RemoteChat['configure'];
 } | {
     readonly status: 'offline';
     readonly conversationId: string | undefined;
     readonly error: string;
+    readonly controller?: undefined;
+    readonly actions?: undefined;
+    readonly configure?: undefined;
 } | {
     readonly status: 'ready';
     readonly conversationId: string;
     readonly controller: NativeChatController;
-    readonly actions: Partial<Pick<RemoteChat, 'answer' | 'withdraw'>>;
+    readonly actions: RemoteActions;
     readonly configure: RemoteChat['configure'];
 };
 export interface RemoteChatHookOptions {
@@ -30,4 +44,5 @@ export interface RemoteChatHookOptions {
 }
 /** One owned native controller per selection; the remote transport itself reopens dropped streams. Failed acquisition retries each second. */
 export declare function useRemoteChat({ conversationId, endpoint, fetch, identity, requestContext, transport, webSocket }: RemoteChatHookOptions): RemoteChatState;
+export {};
 //# sourceMappingURL=chat-react-remote.d.ts.map

package/dist/chat-react-remote.js

@@ -1,5 +1,6 @@
 'use client';
 import { useLayoutEffect, useMemo, useRef } from 'react';
+import { BACKGROUND_CONTEXT } from '@earendil-works/chord/context';
 import { createNativeChatController } from './native-chat.js';
 import { createRemoteChat } from './remote-chat.js';
 import { useControllerPerConversation } from './chat-react-controller.js';
@@ -24,6 +25,34 @@ export function useChatPlacement(controller, placement) {
 export function readChatPlacement(controller) {
     return controller ? placements.get(controller)?.at(-1)?.placement : undefined;
 }
+/**
+ * The conversation and link the controller borrows while the remote chat opens. Each member waits for the remote and then forwards
+ * to it unchanged; the identity is the selection until the server's view names it (the controller reads it again on connect).
+ */
+function pendingConversation(pending, selection) {
+    const forward = (name) => (async (...args) => (await pending.remote).conversation[name](...args));
+    const conversation = {
+        get id() { return (pending.current?.conversation.id ?? selection); },
+        watch: forward('watch'), submit: forward('submit'), abort: forward('abort'), entries: forward('entries'),
+        commit: async (change, context) => (await pending.remote).conversation.commit(change, context),
+    };
+    const link = {
+        reconnecting: () => pending.current?.link.reconnecting() ?? false,
+        subscribe: listener => {
+            let off, gone = false;
+            void pending.remote.then(remote => { if (!gone)
+                off = remote.link.subscribe(listener); }, () => { });
+            return () => { gone = true; off?.(); };
+        },
+    };
+    return { conversation, link };
+}
+/** What a controller that never connected still holds (messages taken from the composer, then the draft), to give to the next attempt. */
+function unsent(controller) {
+    const snapshot = controller.getSnapshot(), drafts = [...snapshot.echo.map(item => item.draft), snapshot.draft];
+    const attachments = drafts.flatMap(item => item.attachments).filter((item, index, all) => all.findIndex(other => other.id === item.id) === index);
+    return { text: drafts.map(item => item.text).filter(text => text.trim()).join('\n'), attachments };
+}
 /** One owned native controller per selection; the remote transport itself reopens dropped streams. Failed acquisition retries each second. */
 export function useRemoteChat({ conversationId, endpoint, fetch, identity, requestContext, transport, webSocket }) {
     const url = conversationId === undefined ? undefined : String(endpoint(conversationId));
@@ -32,30 +61,57 @@ export function useRemoteChat({ conversationId, endpoint, fetch, identity, reque
     useLayoutEffect(() => { latest.current = { fetch, requestContext, webSocket }; });
     // Transport ownership stays with the controller that acquired it, including when connect or selection changes race.
     const remotes = useMemo(() => new WeakMap(), []);
+    // Messages a failed attempt never sent, by selection, for the next attempt's composer.
+    const carried = useMemo(() => new Map(), []);
     const selected = useControllerPerConversation({ key,
-        create: async () => {
+        // The controller exists at once; the remote chat opens behind it (D-1434). Its watch, submits and actions wait for the first view.
+        create: () => {
             let controller;
-            const remote = await createRemoteChat({ endpoint: url, fetch: request => latest.current.fetch(request),
+            const remote = createRemoteChat({ endpoint: url, fetch: request => latest.current.fetch(request),
                 requestContext: () => {
                     const placement = readChatPlacement(controller), screen = latest.current.requestContext?.();
                     return placement || screen ? { ...screen, ...(placement && { placement }) } : undefined;
                 }, ...(transport ? { transport } : {}), ...(latest.current.webSocket ? { webSocket: latest.current.webSocket } : {}) });
+            const pending = { remote,
+                actions: { answer: async (...args) => (await remote).answer(...args), withdraw: async (...args) => (await remote).withdraw(...args) },
+                configure: async (...args) => (await remote).configure(...args) };
+            void remote.then(value => { pending.current = value; }, () => { });
             try {
-                controller = createNativeChatController({ identity: identity, ...remote });
-                remotes.set(controller, remote);
-                return controller;
+                const { conversation, link } = pendingConversation(pending, conversationId);
+                controller = createNativeChatController({ identity: identity, conversation, context: BACKGROUND_CONTEXT, link,
+                    definitelyNotAdmitted: error => pending.current?.definitelyNotAdmitted(error) ?? false });
             }
             catch (error) {
-                await remote.close();
+                void remote.then(value => value.close(), () => { });
                 throw error;
             }
+            remotes.set(controller, pending);
+            const back = carried.get(String(key));
+            if (back) {
+                carried.delete(String(key));
+                if (back.text)
+                    controller.setText(back.text);
+                if (back.attachments.length)
+                    controller.setAttachments(back.attachments);
+            }
+            // `connecting` at once, so the chat shows it and takes messages; the native watch opening waits for the remote's first view.
+            void controller.connect();
+            return controller;
         },
-        connect: controller => controller.connect(),
+        connect: async (controller) => { await remotes.get(controller).remote; await controller.connect(); },
         dispose: async (controller) => {
+            const remote = remotes.get(controller);
+            // Disposed before its first view (a failed connect, or another selection): what it took was held, never submitted (see `send`). Its
+            // words come back in the composer of this selection's next controller, never sent by themselves.
+            if (!controller.getSnapshot().view) {
+                const back = unsent(controller);
+                if (back.text || back.attachments.length)
+                    carried.set(String(key), back);
+            }
             // Start both: closing a transport may release a pending native watch opening.
             const pending = controller.dispose();
             try {
-                await remotes.get(controller)?.close();
+                await (remote?.current ?? await remote?.remote.catch(() => undefined))?.close();
             }
             finally {
                 await pending;
@@ -63,10 +119,13 @@ export function useRemoteChat({ conversationId, endpoint, fetch, identity, reque
             }
         }, });
     if (selected.status === 'ready' && conversationId !== undefined) {
-        const remote = remotes.get(selected.controller);
+        const remote = remotes.get(selected.controller).current;
         const actions = { ...(typeof remote.answer === 'function' ? { answer: remote.answer } : {}),
             ...(typeof remote.withdraw === 'function' ? { withdraw: remote.withdraw } : {}) };
         return { status: 'ready', conversationId, controller: selected.controller, actions, configure: remote.configure };
     }
-    return selected.status === 'offline' ? { status: 'offline', conversationId, error: String(selected.error?.message ?? selected.error) } : { status: 'connecting', conversationId };
+    if (selected.status === 'offline')
+        return { status: 'offline', conversationId, error: String(selected.error?.message ?? selected.error) };
+    const early = selected.controller && remotes.get(selected.controller);
+    return early && selected.controller ? { status: 'connecting', conversationId, controller: selected.controller, actions: early.actions, configure: early.configure } : { status: 'connecting', conversationId };
 }

package/dist/chat-react-session.d.ts

@@ -1,5 +1,5 @@
 import type { ToolCall, ToolResultMessage } from '@earendil-works/pi-ai';
-import type { ChatAttachment, ChatController } from './native-chat.js';
+import type { ChatAttachment, ChatController, ChatSnapshot } from './native-chat.js';
 import type { ChatCard, DeriveOptions, Mode, QueuedMessage, Row } from './chat-view.js';
 /** A conversation's observed file; opening remains a host operation, not workspace ownership. */
 export interface ConversationFile {
@@ -116,9 +116,8 @@ export interface ChatSessionOptions<Content = unknown> extends Partial<DeriveOpt
     /** Focus is presentation; called only by actions, never during render. */
     readonly onFocus?: (() => void) | undefined;
 }
-/** Headless session over the public native controller snapshot/commands. Borrows it; cleanup only aborts this hook's uploads. */
 export declare function useChatSession<Content = unknown>(options: ChatSessionOptions<Content>): {
-    state: import("./native-chat.js").ChatSnapshot;
+    state: ChatSnapshot;
     derived: import("./chat-view.js").Derived<Content>;
     rows: Row<Content>[];
     queued: {

package/dist/chat-react-session.js

@@ -3,6 +3,30 @@ import { useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalS
 import { derive, isFileBlock, object, queuedMessages, waitingForAnswer as waitsForAnswer } from './chat-view.js';
 import { appendToDraft, displayName, kindMentionDraft, looksLikeMarkdown, mentionKind, mentionToken, pieces, prependToDraft, withoutKindMentions, writeKindMentionDraft } from './chat-text.js';
 /** Headless session over the public native controller snapshot/commands. Borrows it; cleanup only aborts this hook's uploads. */
+/**
+ * The snapshot once the controller has its first view (its conversation id is then the server's); undefined if it is disposed, fails or
+ * `signal` aborts first.
+ */
+function connectedSnapshot(controller, signal) {
+    return new Promise(resolve => {
+        let off = () => { }, done = false;
+        const finish = (value) => { if (done)
+            return; done = true; off(); signal.removeEventListener('abort', aborted); resolve(value); };
+        const aborted = () => finish(undefined);
+        const check = () => {
+            const snapshot = controller.getSnapshot(), kind = snapshot.connection.kind;
+            if (signal.aborted)
+                finish(undefined);
+            else if (snapshot.view || snapshot.disposed || kind === 'error' || kind === 'closed')
+                finish(snapshot.view && !snapshot.disposed ? snapshot : undefined);
+        };
+        check();
+        if (done)
+            return;
+        off = controller.subscribe(check);
+        signal.addEventListener('abort', aborted, { once: true });
+    });
+}
 export function useChatSession(options) {
     const { controller, activeController: active, mode, presentation, actions, renderEntry, hideLine, renderTool: catchAll, toolRenderers, groupTool, subagent, onOpenImage, onFiles, mentions, slash, attachments, model, effort, artifacts, afterSend, feedback, onOpenFile, onPickFiles, commandMentions, onFocus, labels } = options;
     const state = useSyncExternalStore(controller.subscribe, controller.getSnapshot, controller.getSnapshot);
@@ -118,7 +142,10 @@ export function useChatSession(options) {
     // Only a submission whose outcome is unknown blocks, until it is checked or retried.
     const unconfirmed = state.send.kind === 'unknown';
     const connected = state.connection.kind === 'connected';
-    const sendBlocked = uploading > 0 || state.disposed || !connected || unconfirmed;
+    // Before the first view the composer already takes messages: the controller holds them, shown as the person's own, and sends them once
+    // connected (or puts them back if the connection fails).
+    const firstConnect = state.connection.kind === 'connecting' && !state.view;
+    const sendBlocked = uploading > 0 || state.disposed || !(connected || firstConnect) || unconfirmed;
     /** Puts a message back into the composer ahead of whatever is there now (nothing is dropped). */
     const putBack = (text, images) => {
         if (controller.getSnapshot().disposed)
@@ -271,8 +298,15 @@ export function useChatSession(options) {
                         paths = [...paths, result.path];
                 }
             }
-            else
-                added = await onFiles(files, { identity: state.identity, conversationId: state.conversationId, signal: abort.signal });
+            else {
+                // While the chat connects its conversation id is still the host's selection: the host's upload waits for the first view's.
+                const target = await connectedSnapshot(controller, abort.signal);
+                if (abort.signal.aborted || !current())
+                    return;
+                if (!target)
+                    throw new Error(labels.uploadFailedShort);
+                added = await onFiles(files, { identity: target.identity, conversationId: target.conversationId, signal: abort.signal });
+            }
             if (current() && !abort.signal.aborted) {
                 if (added.length)
                     controller.setAttachments([...controller.getSnapshot().draft.attachments, ...added]);
@@ -363,7 +397,7 @@ export function useChatSession(options) {
             act(async () => catalog.onActivate({ name: selected.name, behavior: selected.behavior }));
     };
     const empty = connected && !state.view?.entries.length && !rows.length;
-    const loading = (state.connection.kind === 'idle' || state.connection.kind === 'connecting') && !state.view;
+    const loading = (state.connection.kind === 'idle' || state.connection.kind === 'connecting') && !state.view && !echo?.length;
     return { state, derived, rows, queued, queueActions, working, waitingForAnswer, connected, sendBlocked, error, setError, report, act, current,
         files, empty, loading, developer, natural, sending, send, putBack, upload, pasteText, picked, pending, uploading, activateMention,
         pickMention: (path) => setPicked(value => value.includes(path) ? value : [...value, path]),

package/dist/native-chat.d.ts

@@ -86,6 +86,12 @@ export interface NativeChatHistorySource {
     readonly id: Conversation['id'];
     readonly entries: Conversation['entries'];
 }
+/**
+ * Whether entries older than the view's first one exist, when the host says so. A host that sends a slice of the conversation sets
+ * `hasEarlier` on the view it sends (a boolean beside the native fields); without it, a native `head` on a kept entry means earlier entries
+ * exist (a reset or compaction starts the view there). `undefined`: the view does not say.
+ */
+export declare function viewHasEarlier(view: ConversationView | undefined): boolean | undefined;
 export type ChatHistoryState = {
     readonly kind: 'disabled' | 'idle';
 } | {
@@ -195,7 +201,8 @@ export declare function createNativeChatController(options: NativeChatOptions):
     /**
      * Sends the composer draft (or `input`) and empties the composer at once. While another send is still being confirmed the message
      * waits in `outbox` and is submitted, in order, after it. A refused message, and any waiting behind it, go back into the composer
-     * ahead of what was typed since; nothing is dropped or merged into another message. Resolves with the native submission, or
+     * ahead of what was typed since; nothing is dropped or merged into another message. Sent before any view (while connecting), it is
+     * held until the first view arrives and then submitted, in order; if the connection fails first it goes back into the composer. Resolves with the native submission, or
      * undefined when the message was not admitted (refused, unknown, or the controller was disposed).
      */
     send: (whenBusy?: ChatAttempt["whenBusy"], input?: ChatSendInput) => Promise<Submission | undefined>;

package/dist/native-chat.js

@@ -1,5 +1,14 @@
 import { awaitWithContext, withCancel } from '@earendil-works/chord/context';
 import { randomUUID } from '@hachej/boring-files/platform';
+/**
+ * Whether entries older than the view's first one exist, when the host says so. A host that sends a slice of the conversation sets
+ * `hasEarlier` on the view it sends (a boolean beside the native fields); without it, a native `head` on a kept entry means earlier entries
+ * exist (a reset or compaction starts the view there). `undefined`: the view does not say.
+ */
+export function viewHasEarlier(view) {
+    const said = view?.hasEarlier;
+    return typeof said === 'boolean' ? said : undefined;
+}
 function draft(text, attachments, version) {
     if (typeof text !== 'string' || attachments.some(item => typeof item.id !== 'string' || !item.id || typeof item.name !== 'string'
         || item.content.type !== 'image' || typeof item.content.data !== 'string' || typeof item.content.mimeType !== 'string'))
@@ -191,6 +200,17 @@ export function createNativeChatController(options) {
         publish({ send: { kind: 'admitted', attempt, submissionId, ...(record ? { record } : {}) }, ...(found ? { echo: echoView() } : {}) });
         return true;
     };
+    /** Resolves true once a view is there, false if the controller is disposed or its connection fails first. */
+    const viewed = () => snapshot.view ? Promise.resolve(true) : new Promise(resolve => {
+        const check = () => {
+            const failed = snapshot.disposed || snapshot.connection.kind === 'error' || snapshot.connection.kind === 'closed';
+            if (snapshot.view || failed) {
+                listeners.delete(check);
+                resolve(Boolean(snapshot.view) && !snapshot.disposed);
+            }
+        };
+        listeners.add(check);
+    });
     /** Messages taken from the composer that wait for the current send (`outbox` in the snapshot). */
     const waiting = [];
     let sending = false;
@@ -367,15 +387,16 @@ export function createNativeChatController(options) {
             if (previous.kind === 'ready' && !previous.hasMore)
                 return Promise.resolve();
             if (!historyScan) {
-                let maxEntryId;
+                // Earlier means below the view's first entry: the view's own entries are on screen already, so the first page never repeats them.
+                let firstEntryId;
                 for (const entry of snapshot.view?.entries ?? [])
-                    if (maxEntryId === undefined || entry.id > maxEntryId)
-                        maxEntryId = entry.id;
-                if (maxEntryId === undefined) {
+                    if (firstEntryId === undefined || entry.id < firstEntryId)
+                        firstEntryId = entry.id;
+                if (firstEntryId === undefined || firstEntryId <= 0 || viewHasEarlier(snapshot.view) === false) {
                     publish({ history: { kind: 'ready', entries: Object.freeze([]), hasMore: false } });
                     return Promise.resolve();
                 }
-                historyScan = { maxEntryId };
+                historyScan = { maxEntryId: firstEntryId - 1 };
             }
             const scan = historyScan, generation = historyGeneration;
             const entries = 'entries' in previous ? previous.entries : Object.freeze([]);
@@ -445,7 +466,14 @@ export function createNativeChatController(options) {
                     }
                     watch = acquired;
                     const ready = snapshot.timing.inputReady === undefined;
-                    publish({ connection: live(), view: acquired.value, ...(ready ? { timing: Object.freeze({ inputReady: mark('input-ready'), sends: Object.freeze([...timings]) }) } : {}) });
+                    // Messages sent before any view were counted against none; they are held until now (see `send`), so the first view is their baseline.
+                    for (const [index, item] of echoes.entries())
+                        if (item.blind) {
+                            item.blind = false;
+                            firstEntries.set(item.key, acquired.value.entries.length);
+                            item.base = countOf(acquired.value, item.match) + echoes.slice(0, index).filter(other => other.match === item.match).length;
+                        }
+                    publish({ connection: live(), view: acquired.value, ...(snapshot.conversationId !== conversation.id ? { conversationId: conversation.id } : {}), ...(ready ? { timing: Object.freeze({ inputReady: mark('input-ready'), sends: Object.freeze([...timings]) }) } : {}) });
                     acquired.start(async (view) => {
                         if (snapshot.disposed || watch !== acquired)
                             return;
@@ -474,7 +502,8 @@ export function createNativeChatController(options) {
         /**
          * Sends the composer draft (or `input`) and empties the composer at once. While another send is still being confirmed the message
          * waits in `outbox` and is submitted, in order, after it. A refused message, and any waiting behind it, go back into the composer
-         * ahead of what was typed since; nothing is dropped or merged into another message. Resolves with the native submission, or
+         * ahead of what was typed since; nothing is dropped or merged into another message. Sent before any view (while connecting), it is
+         * held until the first view arrives and then submitted, in order; if the connection fails first it goes back into the composer. Resolves with the native submission, or
          * undefined when the message was not admitted (refused, unknown, or the controller was disposed).
          */
         send: async (whenBusy = 'followUp', input) => {
@@ -490,13 +519,15 @@ export function createNativeChatController(options) {
             }
             if (input?.restore)
                 restoreOf.set(selected, draft(input.restore.text, input.restore.attachments ?? [], 0));
+            // Connecting with no view yet: the message is held until the first view (below), which is then its echo's baseline.
+            const held = !snapshot.view && snapshot.connection.kind === 'connecting';
             // The message is the person's from this moment: it is drawn at once (the echo) and the composer is emptied, before any
             // validation or network call. The server's copy replaces it when it arrives; a refusal puts the words back in the composer.
             // (A steer takes a queued message back and sends it again, so it is not echoed twice.)
             if (whenBusy !== 'steer') {
                 const enter = mark('enter');
                 const match = selected.text.trim(), key = `m${++echoSeq}`;
-                echoes.push({ key, draft: selected, match, base: countOf(snapshot.view, match) + echoes.filter(item => item.match === match).length, at: enter, sentAt: Date.now(), failed: false, admitted: false });
+                echoes.push({ key, draft: selected, match, base: countOf(snapshot.view, match) + echoes.filter(item => item.match === match).length, blind: held, at: enter, sentAt: Date.now(), failed: false, admitted: false });
                 firstEntries.set(key, snapshot.view?.entries.length ?? 0);
                 timings.push(Object.freeze({ key, enter }));
                 if (timings.length > 20)
@@ -512,6 +543,12 @@ export function createNativeChatController(options) {
             sending = true;
             publish(cleared);
             try {
+                // Sent while connecting: held (shown as the person's own) until the first view, so nothing is submitted before the connection is up.
+                // If the connection fails first, it and everything behind it go back into the composer, marked not sent.
+                if (held && !await viewed()) {
+                    restore([selected], { send: { kind: 'blocked', reason: 'Not connected: the message was not sent' } });
+                    return;
+                }
                 let next = { draft: selected, whenBusy, resolve: () => { } };
                 const first = await dispatch(next);
                 let result = first;

package/dist/remote-chat.js

@@ -14,6 +14,50 @@ export class SubmissionRefused extends Error {
     code = 'submission-refused';
     constructor(message) { super(message); this.name = 'SubmissionRefused'; }
 }
+/**
+ * A photo the host sends as a link (an image part with a `url`, `data: ''`, so the first view stays small) is handed out with its
+ * `url` resolved against the chat endpoint: a relative link names the endpoint's own route (`?op=image&…`), whatever page the chat is
+ * on. The wire replica stays as sent, so later native operations (a field set, a string append) replay on the host's own values; the
+ * linked copy is derived after each replay. Values are immutable, so a node maps to one linked node for good: unchanged entries keep
+ * their identity and only changed paths are walked again.
+ */
+function imageLinker(base) {
+    const linked = new WeakMap();
+    const link = (node) => {
+        if (!node || typeof node !== 'object')
+            return node;
+        if (linked.has(node))
+            return linked.get(node);
+        let out = node;
+        if (Array.isArray(node)) {
+            const items = node.map(link);
+            if (items.some((item, index) => item !== node[index]))
+                out = items;
+        }
+        else {
+            const record = node;
+            let copy;
+            for (const key of Object.keys(record)) {
+                const value = record[key];
+                const next = key === 'url' && record.type === 'image' && typeof value === 'string' ? resolved(value) : link(value);
+                if (next !== value)
+                    (copy ??= { ...record })[key] = next;
+            }
+            if (copy)
+                out = copy;
+        }
+        linked.set(node, out);
+        return out;
+    };
+    // A link that is not a URL is left as sent: the chat draws a placeholder.
+    const resolved = (url) => { try {
+        return new URL(url, base).href;
+    }
+    catch {
+        return url;
+    } };
+    return (value) => link(value);
+}
 async function reason(response) {
     try {
         const value = await response.json();
@@ -30,6 +74,7 @@ async function reason(response) {
  */
 export async function createRemoteChat(options) {
     const base = new URL(options.endpoint, globalThis.location?.href);
+    const linkImages = imageLinker(base);
     const send = options.fetch, pollMs = options.pollMs ?? 500;
     const backoff = { base: options.reconnect?.baseDelayMs ?? 1000, max: options.reconnect?.maxDelayMs ?? 30_000 };
     const url = (op, extra = {}) => {
@@ -265,7 +310,7 @@ export async function createRemoteChat(options) {
             settle(end);
         } };
         const handle = {
-            get value() { return value; },
+            get value() { return linkImages(value); },
             closed,
             lost: () => lost,
             stop: async () => { finish({ reason: 'stopped' }); return closed; },
@@ -288,7 +333,7 @@ export async function createRemoteChat(options) {
                             // Native operation batches are replayed with the upstream delta implementation; a view frame resets the replica.
                             value = frame.kind === 'view' ? frame.view : applyImmutable(value, frame.ops);
                             try {
-                                await listener(value, [], context);
+                                await listener(linkImages(value), [], context);
                             }
                             catch (error) {
                                 return finish({ reason: 'listener_error', error: error instanceof Error ? error : new Error(String(error)) });
@@ -345,7 +390,8 @@ export async function createRemoteChat(options) {
             cancelRetry();
             setReconnecting(false);
             settle(end);
-            const live = current;
+            // Stopped before it started (the owner left while the first view was on its way, D-1434): the first watch is still open, close it.
+            const live = current ?? (listener ? undefined : first);
             current = undefined;
             void live?.stop();
         };
@@ -478,11 +524,11 @@ export async function createRemoteChat(options) {
         // The controller only reconciles a submission by request ID; no other transaction work crosses the wire.
         commit: async (change, _context) => change({ submissionByRequest: (_conversationId, requestId) => lookup(requestId) }),
         abort: async () => { await post('abort', {}); },
-        entries: async (query, limit, cursor) => (await call('entries', {}, { limit: String(limit),
+        entries: async (query, limit, cursor) => linkImages((await call('entries', {}, { limit: String(limit),
             ...(query.maxEntryId === undefined ? {} : { maxEntryId: String(query.maxEntryId) }),
             ...(query.minEntryId === undefined ? {} : { minEntryId: String(query.minEntryId) }),
             ...(query.order === undefined ? {} : { order: query.order }),
-            ...(cursor === undefined ? {} : { cursor: JSON.stringify(cursor) }) })).page,
+            ...(cursor === undefined ? {} : { cursor: JSON.stringify(cursor) }) })).page),
     };
     const context = BACKGROUND_CONTEXT;
     const close = async () => { const first = unclaimed; unclaimed = undefined; await first?.stop(); };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-ui-kit",
-  "version": "0.4.50",
+  "version": "0.4.51",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -154,7 +154,7 @@
     }
   },
   "peerDependencies": {
-    "@hachej/boring-files": "^0.4.50",
+    "@hachej/boring-files": "^0.4.51",
     "@earendil-works/pi-durable": "~1.4.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",

package/r/agent-target.json

@@ -4,15 +4,15 @@
   "title": "Point and dictate on app data",
   "description": "Tap explicitly marked JSON app context, dictate once and show the same app agent’s native reply without opening chat. Host-controlled presentation; no feedback report or second controller.",
   "dependencies": [
-    "@hachej/boring-ui-kit@^0.4.50",
-    "@hachej/boring-feedback@^0.4.50",
+    "@hachej/boring-ui-kit@^0.4.51",
+    "@hachej/boring-feedback@^0.4.51",
     "@earendil-works/pi-durable@~1.4.0",
     "react@^19.0.0",
     "react-dom@^19.0.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/app-shell.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/pi-chat.json"
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/app-shell.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/pi-chat.json"
   ],
   "files": [
     {

package/r/app-shell.json

@@ -4,21 +4,21 @@
   "title": "App shell: layouts, list/detail and agent layer",
   "description": "AppShell with three layouts. B \"workspace\" puts a ListDetail on a screen (phone: the list, then the detail as a stack step with Back; wide: a 20rem list and the detail side by side, sidebar as an icon rail). C \"chat\" wraps the app's own AgentWorkspace (untouched, passed as the nav item's render; install the pi-app item yourself) in the same sidebar, account menu and header; it takes no shell agent. A \"screen\": one screen at a time, every screen kept mounted. On a phone bottom tabs (at most four; more give three plus a « Plus » sheet) and an avatar button that opens the account sheet; on a wide screen the shadcn sidebar (icon rail, NavUser). One header per screen through useScreenHeader (title, subtitle, back, up to two actions, the rest behind « … »). The account menu holds « Améliorer l'app » (the improve agent), the app's own entries and sign out. AppSheet is the one bottom sheet (one open at a time, Back closes it). It mounts the AgentLayer: one agent's PiChat above the app (phone: a drawer with peek, half and full snap points; wide: a right panel), the improve agent in the same layer, optional push-to-talk and point mode. Also useAgentContext and readAgentContext (the screen on show travels as `context` with each submit) and useBackLayer, the one Back manager. Built on explicitly pinned Base UI drawer and dropdown-menu recipes, plus the sidebar and avatar of the host's own shadcn style.",
   "dependencies": [
-    "@hachej/boring-feedback@^0.4.50",
-    "@hachej/boring-ui-kit@^0.4.50",
+    "@hachej/boring-feedback@^0.4.51",
+    "@hachej/boring-ui-kit@^0.4.51",
     "@base-ui/react@^1.9.0",
     "react@^19.0.0",
     "react-dom@^19.0.0",
     "lucide-react@^1.51.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/pi-chat.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/pi-chat-plugins.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/pi-chat-voice.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/dock.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/feedback.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/utils.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/button.json"
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/pi-chat.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/pi-chat-plugins.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/pi-chat-voice.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/dock.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/feedback.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/utils.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/button.json"
   ],
   "files": [
     {

package/r/board-viewer.json

@@ -4,17 +4,17 @@
   "title": "Board viewer",
   "description": "A board@1 artifact kind for *.board.json. Lazy native tldraw projection of maquette screens, sandboxed HTML mock-ups, goto arrows and notes. Conditional board-file autosave; phone viewing without accidental frame edits. Hosts supply their resource client, asset URLs and license key.",
   "dependencies": [
-    "@hachej/boring-ui-kit@^0.4.50",
-    "@hachej/boring-files@^0.4.50",
+    "@hachej/boring-ui-kit@^0.4.51",
+    "@hachej/boring-files@^0.4.51",
     "react@^19.0.0",
     "lucide-react@1.51.0",
     "tldraw@5.5.2"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/maquette-viewer.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/mockup-viewer.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/pi-artifacts.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/utils.json"
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/maquette-viewer.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/mockup-viewer.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/pi-artifacts.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/utils.json"
   ],
   "files": [
     {

package/r/button.json

@@ -9,7 +9,7 @@
     "lucide-react@^1.51.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.50/r/utils.json"
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.51/r/utils.json"
   ],
   "files": [
     {