@hachej/boring-ui-kit 0.4.49 → 0.4.51

package/THIRD_PARTY_NOTICES.md

@@ -118,3 +118,211 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
+
+## draw.io viewer (`@hachej/boring-ui-kit/drawio-viewer`)
+
+The kit carries, unmodified, `viewer-static.min.js` of jgraph/drawio v32.4.1 (https://github.com/jgraph/drawio, sha256 bc7586cb62eec98018c13b78619078d3a7179cc7bfc711c566dda19527520a30), Copyright JGraph Ltd, as the text of `src/vendor/drawio-viewer-static.ts`. The project has no NOTICE file. The script bundles DOMPurify (Apache-2.0 or MPL-2.0), pako (MIT and Zlib) and other libraries whose notices it keeps inline. Its licence:
+
+```text
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+```

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/drawio-viewer.d.ts

@@ -0,0 +1,4 @@
+export { DRAWIO_VIEWER_SCRIPT } from './vendor/drawio-viewer-static.js';
+/** The jgraph/drawio release the vendored viewer comes from. */
+export declare const DRAWIO_VIEWER_VERSION = "32.4.1";
+//# sourceMappingURL=drawio-viewer.d.ts.map

package/dist/drawio-viewer.js

@@ -0,0 +1,6 @@
+// `@hachej/boring-ui-kit/drawio-viewer` (D-1398): the official diagrams.net viewer, vendored and pinned (scripts/vendor-drawio-viewer.mjs),
+// as text. The drawing-viewer registry block imports this subpath lazily, only when a draw.io file opens, and runs the text inside its
+// sandboxed frame: nothing is fetched from diagrams.net. The kit never evaluates it.
+export { DRAWIO_VIEWER_SCRIPT } from './vendor/drawio-viewer-static.js';
+/** The jgraph/drawio release the vendored viewer comes from. */
+export const DRAWIO_VIEWER_VERSION = '32.4.1';

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;