dsh-remote-vs 0.9.1 → 0.9.2

package/lib/client.js

@@ -2725,7 +2725,7 @@ window.__ModuleLoader__.load({
 				let text = from <= 0 && to >= this.length ? this : new TextLeaf(sliceText(this.text, from, to), Math.min(to, this.length) - Math.max(0, from));
 				if (open & 1) {
 					let prev = target.pop();
-					let joined = appendText(text.text, prev.text.slice(), 0, text.length);
+					let joined = appendText$1(text.text, prev.text.slice(), 0, text.length);
 					if (joined.length <= 32) target.push(new TextLeaf(joined, prev.length + text.length));
 					else {
 						let mid = joined.length >> 1;
@@ -2736,7 +2736,7 @@ window.__ModuleLoader__.load({
 			replace(from, to, text) {
 				if (!(text instanceof TextLeaf)) return super.replace(from, to, text);
 				[from, to] = clip(this, from, to);
-				let lines = appendText(this.text, appendText(text.text, sliceText(this.text, 0, from)), to);
+				let lines = appendText$1(this.text, appendText$1(text.text, sliceText(this.text, 0, from)), to);
 				let newLen = this.length + text.length - (to - from);
 				if (lines.length <= 32) return new TextLeaf(lines, newLen);
 				return TextNode.from(TextLeaf.split(lines, []), newLen);
@@ -2897,7 +2897,7 @@ window.__ModuleLoader__.load({
 			for (let line of text) length += line.length + 1;
 			return length;
 		}
-		function appendText(text, target, from = 0, to = 1e9) {
+		function appendText$1(text, target, from = 0, to = 1e9) {
 			for (let pos = 0, i = 0, first = true; i < text.length && pos <= to; i++) {
 				let line = text[i], end = pos + line.length;
 				if (end >= from) {
@@ -2913,7 +2913,7 @@ window.__ModuleLoader__.load({
 			return target;
 		}
 		function sliceText(text, from, to) {
-			return appendText(text, [""], from, to);
+			return appendText$1(text, [""], from, to);
 		}
 		var RawTextCursor = class {
 			constructor(text, dir = 1) {
@@ -35127,127 +35127,202 @@ window.__ModuleLoader__.load({
 			}
 		}
 		/**
-		* Splice `text` into `draft` at `caret` (replacing any live selection) with
-		* whitespace-aware joins and report the caret position right after the
-		* inserted text. `caret === null` (position unknown) appends at the end,
-		* exactly like the original behavior.
+		* The separating space an append needs on its left — one space, but never
+		* doubled against existing whitespace. Both the string append and the span
+		* channel (which does no splice math of its own) obey this single rule. A blank
+		* draft takes no separator: it is replaced outright.
 		*/
-		function spliceInsert(draft, text, caret) {
-			if (caret === null || draft === "") {
-				const next = draft.trim() === "" ? text : `${draft}${/\s$/.test(draft) ? "" : " "}${text}`;
+		function leadFor(draft) {
+			if (draft.trim() === "") return "";
+			return /\s$/.test(draft) ? "" : " ";
+		}
+		/** `draft` with `text` appended behind one separating space when needed. */
+		function appendText(draft, text) {
+			return `${draft}${leadFor(draft)}${text}`;
+		}
+		/**
+		* Fold one clipboard-projection offset to its detect-projection twin.
+		*
+		* An offset inside a chip's expansion snaps to that chip's trailing edge (the
+		* host only ever replaces whole chips, never splits one). An offset exactly at
+		* a chip's START resolves to the position BEFORE the chip — the host's own
+		* `detectOffsetOfClipboardOffset` reads that case as "inside" and would move a
+		* caret one chip too far right.
+		*/
+		function foldClipboardOffset(draft, occurrences, offset) {
+			const target = Math.max(0, Math.min(offset, draft.length));
+			let shrink = 0;
+			for (const occurrence of occurrences) {
+				if (target >= occurrence.offset + occurrence.length) {
+					shrink += occurrence.length - 1;
+					continue;
+				}
+				if (target > occurrence.offset) return occurrence.offset - shrink + 1;
+				break;
+			}
+			return target - shrink;
+		}
+		/**
+		* The detect-projection offset that appends at the document end, or
+		* `undefined` when it cannot be derived.
+		*
+		* `foldClipboardOffset` alone is not enough: a command chip (`/goal `, present
+		* while `phase === 'claimed'`) collapses to one detect character but never
+		* appears in `occurrences` — the host only collects REFERENCE chips.
+		*
+		* CORRECTION over the upstream 0.28.1 formula: the chip's clipboard text is
+		* `claim.token.trimEnd()` and the separator is a SEPARATE text node, so the
+		* detect projection is `1 (chip) + separator.length + rest`. Upstream folds the
+		* whole `claim.token` into that one placeholder, which lands one character
+		* short — a selection or `@file` appended while a slash command is claimed then
+		* splices INSIDE the command's last argument word (`/goal do it` became
+		* `/goal do i <payload>t`). Verified against the installed host:
+		* `CommandChipNode.getTextContent()` returns the token without its separator,
+		* and `insertCommand` inserts the separator as its own text node.
+		*/
+		function appendOffset(snapshot) {
+			const { draft, claim } = snapshot;
+			const occurrences = snapshot.occurrences ?? [];
+			const token = snapshot.phase === "claimed" && claim !== void 0 && draft.startsWith(claim.token) ? claim.token : "";
+			if (token === "") return foldClipboardOffset(draft, occurrences, draft.length);
+			const separator = token.slice(token.trimEnd().length);
+			const rest = draft.slice(token.length);
+			return 1 + separator.length + foldClipboardOffset(rest, occurrences.filter((occurrence) => occurrence.offset >= token.length).map((occurrence) => ({
+				offset: occurrence.offset - token.length,
+				length: occurrence.length
+			})), rest.length);
+		}
+		/**
+		* Whether the session's draft revision moved past `revision` — the only
+		* trustworthy success signal after an exception swallowed the host's answer.
+		*/
+		function revisionChanged(ctx, sessionId, revision) {
+			try {
+				const actx = sessionScope(ctx, sessionId);
+				if (actx === void 0) return false;
+				const now = conversationOf(ctx)?.input.for(actx).state.getSnapshot().draftRev;
+				if (now === void 0 || revision === void 0) return false;
+				return now !== revision;
+			} catch {
+				return false;
+			}
+		}
+		/** One session's resolved input facade, or a logged reason why not. */
+		function inputFor(ctx, sessionId, reason) {
+			const actx = sessionScope(ctx, sessionId);
+			if (actx === void 0) {
+				console.warn(`[dsh-remote-vs] ${reason}: no session scope`, sessionId);
+				return;
+			}
+			const conversation = conversationOf(ctx);
+			if (conversation === void 0) {
+				console.warn(`[dsh-remote-vs] ${reason}: conversation service unavailable`);
+				return;
+			}
+			try {
 				return {
-					draft: next,
-					caretAfter: next.length
+					actx,
+					input: conversation.input.for(actx)
 				};
+			} catch (error) {
+				console.warn(`[dsh-remote-vs] ${reason}: input facade unavailable`, error);
+				return;
 			}
-			const prefix = draft.slice(0, caret.start);
-			const suffix = draft.slice(caret.end);
-			if (prefix === "" && suffix === "") return {
-				draft: text,
-				caretAfter: text.length
-			};
-			const left = prefix === "" || /\s$/.test(prefix) ? "" : " ";
-			return {
-				draft: `${prefix}${left}${text}${suffix === "" || /^\s/.test(suffix) || /\s$/.test(text) ? "" : " "}${suffix}`,
-				caretAfter: prefix.length + left.length + text.length
-			};
 		}
 		/**
-		* Locate the composer `<textarea>` in the conversation column: prefer the
-		* `data-phase`-tagged textarea (the composer's marker), falling back to any
-		* textarea in the column, then to a bare data-phase textarea (older host
-		* layouts without the column attribute). Null in jsdom-less hosts — and on
-		* DSH 0.2.1, whose composer is a Lexical contenteditable (the probe then
-		* misses and callers append at the end, matching the local explorer).
+		* Mint one reference chip through the host's public `insertReference` facade —
+		* the same method the native `@` picker's event listener calls, so the
+		* composer shows a compact chip while the model receives `reference.text`.
+		* The host runs its own admission-phase and revision guards and reports whether
+		* the edit applied.
+		*
+		* The chip's `clipboardText` is the compact `label` by default, not the full
+		* payload: other draft consumers (copy, plain projections) stay short, and the
+		* full payload rides in `text` for send.
+		*
+		* @returns false when the host refused the insert (stale revision, frozen
+		*   submission phase, or no chip channel) so the caller can fall back.
 		*/
-		function findComposerTextarea() {
-			if (typeof document === "undefined") return null;
-			const column = document.querySelector("#root [data-slot=\"conversation\"]");
-			const find = (scope) => scope.querySelector("textarea[data-phase]") ?? scope.querySelector("textarea");
-			return column !== null ? find(column) : document.querySelector("textarea[data-phase]");
-		}
-		/**
-		* Resolve the composer's live caret from its DOM `<textarea>`. The draft
-		* store has no caret API, so the value-sync check (`el.value === draft`)
-		* discards stale or wrong-composer reads — a caret must never be applied
-		* against a draft it was not measured on.
-		*
-		* Returns null when the composer is missing, disabled/read-only, out of
-		* sync with the store draft, or has no measurable selection (jsdom/odd
-		* hosts report null selectionStart/End).
-		*/
-		function probeComposerCaret(draft) {
-			const el = findComposerTextarea();
-			if (el === null || el.disabled || el.readOnly) return null;
-			if (el.value !== draft) return null;
-			let start = el.selectionStart;
-			let end = el.selectionEnd;
-			if (typeof start !== "number" || typeof end !== "number") return null;
-			if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
-			start = Math.max(0, Math.min(start, draft.length));
-			end = Math.max(start, Math.min(end, draft.length));
-			return {
-				start,
-				end
-			};
-		}
-		/**
-		* Restore the composer caret to `caretIndex` after a programmatic
-		* `setDraft` commit. A controlled textarea update resets the caret (React
-		* commits the value asynchronously and the browser moves the caret to the
-		* start/end), so the placement is scheduled and retried across at most two
-		* animation frames (setTimeout fallback for jsdom), and only applied when
-		* the textarea still matches `expectedDraft` — a newer edit or a different
-		* composer wins the race untouched. The caret is clamped into the value
-		* bounds, mirroring how browsers clamp type-in positions.
-		*/
-		function placeComposerCaretAfterInsert(expectedDraft, caretIndex) {
-			let remaining = 2;
-			let scheduled = false;
-			const schedule = (fn) => {
-				if (scheduled) return;
-				scheduled = true;
-				if (typeof requestAnimationFrame === "function") requestAnimationFrame(fn);
-				else setTimeout(fn, 0);
-			};
-			const place = () => {
-				scheduled = false;
-				if (remaining <= 0) return;
-				remaining -= 1;
-				const el = findComposerTextarea();
-				if (el === null || el.disabled || el.readOnly) return;
-				if (el.value !== expectedDraft) {
-					schedule(place);
-					return;
-				}
-				const clamped = Math.max(0, Math.min(caretIndex, el.value.length));
-				el.setSelectionRange(clamped, clamped);
-			};
-			schedule(place);
+		function insertDraftReference(ctx, sessionId, reference) {
+			let before;
+			try {
+				const resolved = inputFor(ctx, sessionId, "reference chip skipped");
+				if (resolved === void 0) return false;
+				const { actx, input } = resolved;
+				const snapshot = input.state.getSnapshot();
+				if (input.insertReference === void 0 || snapshot.draftRev === void 0) return false;
+				if (snapshot.phase === "adjudicating" || snapshot.phase === "submitting") return false;
+				before = snapshot.draftRev;
+				const at = appendOffset(snapshot);
+				if (at === void 0) return false;
+				let rev = snapshot.draftRev;
+				let start = at;
+				if (leadFor(snapshot.draft) !== "") {
+					actx.emit?.("slash/input-insert-text", {
+						text: " ",
+						span: {
+							draftRev: rev,
+							start: at,
+							end: at
+						}
+					});
+					const afterSpace = input.state.getSnapshot();
+					if (afterSpace.draftRev === rev) return false;
+					rev = afterSpace.draftRev ?? rev;
+					start = at + 1;
+				}
+				const chip = {
+					source: "reference",
+					ref: reference.text,
+					label: reference.label,
+					...reference.appearance === void 0 ? {} : { appearance: reference.appearance },
+					clipboardText: reference.clipboardText ?? reference.label
+				};
+				return input.insertReference(chip, {
+					draftRev: rev,
+					start,
+					end: start
+				});
+			} catch (error) {
+				console.warn("[dsh-remote-vs] reference chip insert failed:", error);
+				return revisionChanged(ctx, sessionId, before);
+			}
 		}
 		/**
-		* Insert `text` into the session's composer draft at the composer's live
-		* caret (see {@link probeComposerCaret}), falling back to appending at the
-		* end when the caret cannot be resolved. Returns false — and logs — when the
-		* conversation service or the session scope is unavailable.
+		* Append `text` to the session's composer draft. Returns false — and logs —
+		* when the conversation service or the session scope is unavailable.
+		*
+		* A chipless draft takes the plain `setDraft` path. A draft that CARRIES chips
+		* is written through `slash/input-insert-text` at the folded end offset
+		* instead: `setDraft` rebuilds the document from a string and flattens every
+		* chip, which quietly destroys references the user placed by hand. The same
+		* span path covers a claimed `/command`, whose prefix chip is not in
+		* `occurrences` (see {@link appendOffset}).
 		*/
 		function appendToDraft(ctx, sessionId, text) {
 			try {
-				const actx = sessionScope(ctx, sessionId);
-				if (actx === void 0) {
-					console.warn("[dsh-remote-vs] draft insert skipped: no session scope", sessionId);
-					return false;
-				}
-				const conversation = conversationOf(ctx);
-				if (conversation === void 0) {
-					console.warn("[dsh-remote-vs] draft insert skipped: conversation service unavailable");
-					return false;
+				const resolved = inputFor(ctx, sessionId, "draft insert skipped");
+				if (resolved === void 0) return false;
+				const { actx, input } = resolved;
+				const snapshot = input.state.getSnapshot();
+				const draft = snapshot.draft;
+				if ((snapshot.occurrences ?? []).length > 0 || snapshot.phase === "claimed") {
+					const at = appendOffset(snapshot);
+					if (snapshot.draftRev === void 0 || at === void 0) {
+						console.warn("[dsh-remote-vs] draft insert skipped: chip draft without a revision");
+						return false;
+					}
+					actx.emit?.("slash/input-insert-text", {
+						text: `${leadFor(draft)}${text}`,
+						span: {
+							draftRev: snapshot.draftRev,
+							start: at,
+							end: at
+						}
+					});
+					return input.state.getSnapshot().draftRev !== snapshot.draftRev;
 				}
-				const input = conversation.input.for(actx);
-				const draft = input.state.getSnapshot().draft;
-				const { draft: next, caretAfter } = spliceInsert(draft, text, probeComposerCaret(draft));
-				input.setDraft(next);
-				placeComposerCaretAfterInsert(next, caretAfter);
+				input.setDraft(appendText(draft, text));
 				return true;
 			} catch (error) {
 				console.warn("[dsh-remote-vs] draft insert failed:", error);
@@ -35255,6 +35330,15 @@ window.__ModuleLoader__.load({
 			}
 		}
 		/**
+		* Insert one reference as a chip, degrading to its plain-text form when the
+		* host has no chip channel or refuses the insert. This is the ONE place the
+		* fallback policy lives: the explorer's `@` button and the viewer selection
+		* popup both come through here.
+		*/
+		function insertReferenceOrText(ctx, sessionId, reference) {
+			return insertDraftReference(ctx, sessionId, reference) || appendToDraft(ctx, sessionId, reference.text);
+		}
+		/**
 		* The DSH `@` spelling for one relative path, mirroring the host grammar
 		* (`formatFileMention` in `@deepseek-ai/dsh-file-reference`): plain when
 		* there is no whitespace, quoted when there is, and `undefined` when the
@@ -35325,12 +35409,12 @@ window.__ModuleLoader__.load({
 		}
 		/**
 		* Insert one remote explorer entry into the session's composer draft. Files
-		* mint a structured chip like the native `@` picker
-		* (`insertFileReference`); directories append the folder mention as plain
-		* text so DSH's folder decoration and completion keep working. The caller
-		* owns the binding gate (the session must belong to the viewed binding —
-		* see `use-remote-chat-target.ts`); an unrepresentable path is a logged
-		* no-op, never an absolute mention.
+		* mint a structured chip exactly like the native `@` picker (same facade the
+		* viewer selection popup uses, with a plain-text fallback); directories append
+		* the folder mention as plain text so DSH's folder decoration and completion
+		* keep working. The caller owns the binding gate (the session must belong to
+		* the viewed binding — see `use-remote-chat-target.ts`); an unrepresentable
+		* path is a logged no-op, never an absolute mention.
 		*/
 		function insertRemoteReference(ctx, sessionId, remoteRoot, absPath, isDir) {
 			if (ctx === void 0) return false;
@@ -35340,55 +35424,20 @@ window.__ModuleLoader__.load({
 					console.warn("[dsh-remote-vs] reference insert skipped: path outside the remote workspace root");
 					return false;
 				}
-				const mention = isDir ? directoryMention(relative) : mentionFor(relative, "file")?.mention;
-				if (mention === void 0) {
+				const token = isDir ? directoryMention(relative) : mentionFor(relative, "file")?.mention;
+				if (token === void 0) {
 					console.warn("[dsh-remote-vs] reference insert skipped: path cannot be represented as a mention");
 					return false;
 				}
-				if (!isDir && insertFileReference(ctx, sessionId, relative)) return true;
-				return appendToDraft(ctx, sessionId, isDir ? `${mention} ` : mention);
-			} catch (error) {
-				console.warn("[dsh-remote-vs] remote-reference insert failed:", error);
-				return false;
-			}
-		}
-		/**
-		* Insert one FILE reference as a structured chip (like DSH's own `@` picker).
-		* The chip displays `@<basename>` but serializes to `@<relative path>` on
-		* send, so the reference stays a single link from trigger to basename.
-		*
-		* Directories keep the plain-text completion behavior (`@dir/`) through
-		* `insertRemoteReference`. The rc.1 picker also supports folder chips on
-		* explicit selection; its drill action still inserts plain text.
-		*/
-		function insertFileReference(ctx, sessionId, relativePath) {
-			const reference = mentionFor(relativePath, "file");
-			if (reference === void 0) return false;
-			try {
-				const actx = sessionScope(ctx, sessionId);
-				if (actx === void 0) return false;
-				const conversation = conversationOf(ctx);
-				if (conversation === void 0) return false;
-				const input = conversation.input.for(actx);
-				const before = input.state.getSnapshot();
-				if (before.draftRev === void 0) return false;
-				actx.emit("slash/input-insert-reference", {
-					reference: {
-						source: "reference",
-						ref: reference.mention,
-						label: reference.label,
-						appearance: "file",
-						clipboardText: reference.mention
-					},
-					span: {
-						draftRev: before.draftRev,
-						start: before.draft.length,
-						end: before.draft.length
-					}
+				if (isDir) return appendToDraft(ctx, sessionId, `${token} `);
+				return insertReferenceOrText(ctx, sessionId, {
+					label: mentionFor(relative, "file")?.label ?? token,
+					text: token,
+					clipboardText: token,
+					appearance: "file"
 				});
-				return input.state.getSnapshot().draftRev !== before.draftRev;
 			} catch (error) {
-				console.warn("[dsh-remote-vs] file-reference insert failed:", error);
+				console.warn("[dsh-remote-vs] remote-reference insert failed:", error);
 				return false;
 			}
 		}
@@ -35403,14 +35452,25 @@ window.__ModuleLoader__.load({
 			return `${rel}:${lines.start}`;
 		}
 		/**
-		* The full text appended to the composer draft for one selection.
-		* Over the limit the content is dropped: the plain path line is the whole
-		* payload (an empty fenced block would just occupy the draft).
+		* The composer payload for one selection: the chip label and the model text.
+		*
+		* The chip reads as `rel:start-end` (compact, and it is what the draft
+		* projection carries); the model receives the whole fenced block. Over the
+		* limit the content is dropped and BOTH halves are the plain path line — an
+		* empty fenced block would just occupy the draft. No `appearance` is set: the
+		* host can make `'file'` chips openable, and a selection's `text` is not a
+		* path, so a click must not hand a fenced block to the file opener.
 		*/
 		function buildRemoteSelectionInsert(absPath, remoteRoot, lines, selected) {
 			const header = remoteHeaderOf(remoteRoot, absPath, lines);
-			if (selected.length > 500) return header;
-			return `\`\`\`${header}\n${selected}\n\`\`\``;
+			if (selected.length > 500) return {
+				label: header,
+				text: header
+			};
+			return {
+				label: header,
+				text: `\`\`\`${header}\n${selected}\n\`\`\``
+			};
 		}
 		//#endregion
 		//#region src/client/selection-popup.ts
@@ -37485,7 +37545,7 @@ Integer Float Double Long Int32 Int64 Uint8 uint32_t int32_t uint64_t int64_t si
 				onCommit: (insert) => {
 					const ctx = ctxRef.current;
 					const sessionId = targetRef.current.sessionId;
-					if (ctx !== void 0 && sessionId !== void 0) appendToDraft(ctx, sessionId, insert);
+					if (ctx !== void 0 && sessionId !== void 0) insertReferenceOrText(ctx, sessionId, insert);
 				},
 				getSurface: () => hostRef.current
 			});
@@ -38061,7 +38121,7 @@ Integer Float Double Long Int32 Int64 Uint8 uint32_t int32_t uint64_t int64_t si
 					const primary = host.querySelectorAll("[class*=\"rvs-ck-\"]").length;
 					const fallback = host.querySelectorAll("span[class^=\"rvs-t-\"]").length;
 					const count = primary > 0 ? primary : fallback;
-					console.info(`[dsh-remote-vs] build 1027-1824 · ${source} · colored tokens: ${count} (${propsRef.current.path})`);
+					console.info(`[dsh-remote-vs] build 1027-1916 · ${source} · colored tokens: ${count} (${propsRef.current.path})`);
 					propsRef.current.onTokens?.(count);
 				};
 				const armFallback = () => {
@@ -43902,8 +43962,8 @@ Integer Float Double Long Int32 Int64 Uint8 uint32_t int32_t uint64_t int64_t si
 						}),
 						/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
 							className: "rvs-build",
-							title: `dsh-remote-vs build 1027-1824`,
-							children: "1027-1824"
+							title: `dsh-remote-vs build 1027-1916`,
+							children: "1027-1916"
 						}),
 						tokenCount !== void 0 && /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("span", {
 							className: "rvs-build",