@khorsheed/dsh-client-message-tools 0.1.0

package/lib/types/client/edit-in-place.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Edit choreography shared by the shadowed renderers: cancel the running turn
+ * (waiting for it to settle so its teardown writes land before the
+ * replacement), then apply the in-place edit, which itself triggers the
+ * regeneration turn. Kept free of services so the unit tests drive it with
+ * stub verbs.
+ */
+/** The verbs of one in-place edit, bound to a session by the caller. */
+export interface EditInPlaceSteps {
+    /** Cancel the session's running turn. */
+    cancel: () => Promise<void>;
+    /** Wait until the cancelled turn has fully settled (bounded; never hangs). */
+    waitIdle: () => Promise<void>;
+    /** Apply the edit (single Remote call: replace + trigger regeneration). */
+    edit: () => Promise<void>;
+}
+/**
+ * Edit one user message in place: when the session has a running turn, cancel
+ * it first (it is writing into the span the edit is about to shadow) and wait
+ * for the settle, then apply the edit. A failed cancel rejects without
+ * editing; a failed or timed-out settle wait rejects without editing too —
+ * editing before the cancelled turn's teardown has landed would leak the
+ * straggler tool results outside the replacement's span. An idle session is
+ * never cancelled.
+ * @param steps - the cancel/waitIdle/edit verbs.
+ * @param running - whether the session has a running turn right now.
+ * @returns completion; failures reject at the failing step.
+ */
+export declare function editInPlace(steps: EditInPlaceSteps, running: boolean): Promise<void>;
+/** The verbs of one withdrawal, bound to a session by the caller. */
+export interface WithdrawInPlaceSteps {
+    /** Cancel the session's running turn. */
+    cancel: () => Promise<void>;
+    /** Wait until the cancelled turn has fully settled (bounded; never hangs). */
+    waitIdle: () => Promise<void>;
+    /** Apply the withdrawal (single Remote call: surface replacement + flush). */
+    withdraw: () => Promise<void>;
+}
+/**
+ * Withdraw one user message: when the session has a running turn, cancel it
+ * first (it is writing into the span the withdrawal is about to shadow) and
+ * wait for the settle, then apply the withdrawal. A failed cancel rejects
+ * without withdrawing; a failed or timed-out settle wait rejects without
+ * withdrawing too — withdrawing before the cancelled turn's teardown has
+ * landed would leave straggler chunks/assistant writes outside the
+ * replacement's span. An idle session is never cancelled.
+ * @param steps - the cancel/waitIdle/withdraw verbs.
+ * @param running - whether the session has a running turn right now.
+ * @returns completion; failures reject at the failing step.
+ */
+export declare function withdrawInPlace(steps: WithdrawInPlaceSteps, running: boolean): Promise<void>;
+/**
+ * The minimal slice of the client conversation snapshot the settle probe
+ * reads (structurally satisfied by `ConversationSnapshot`, so the unit tests
+ * stub only these fields).
+ */
+export interface TurnSettleSnapshot {
+    running: boolean;
+    runningCalls: readonly unknown[];
+    chat: {
+        timeline: {
+            turnOrder: readonly number[];
+            turns: ReadonlyMap<number, {
+                readonly status: 'open' | 'closed' | 'unknown';
+            }>;
+        };
+    };
+}
+/**
+ * Whether the cancelled turn's teardown has fully landed in the session log.
+ * `running` flips false FIRST (host status push), the cancelled tool results
+ * persist after that, and the `turn/end` event lands last — an edit computed
+ * in between shadows a span that ends before those stragglers, leaving orphan
+ * tool messages in the model context (the model API then rejects the
+ * request). The authoritative settle signal is the latest turn's timeline
+ * location closing (turn/end is written after every result); `running` and
+ * `runningCalls` are earlier short-circuits. An empty turn order means the
+ * running turn's `turn/start` has not streamed in yet — not settled either.
+ * @param snapshot - the session's current conversation snapshot.
+ * @returns true only when every teardown write of the latest turn has landed.
+ */
+export declare function turnSettled(snapshot: TurnSettleSnapshot): boolean;
+/** Tuning of {@link waitForTurnSettled}; the defaults match production. */
+export interface SettleWaitOptions {
+    /** Overall bound; the wait rejects when it expires (default 5s). */
+    timeoutMs?: number;
+    /** Poll interval between snapshot reads (default 100ms). */
+    intervalMs?: number;
+    /** Clock override for tests. */
+    now?: () => number;
+    /** Sleep override for tests. */
+    sleep?: (ms: number) => Promise<void>;
+}
+/**
+ * Poll until the cancelled turn has fully settled ({@link turnSettled}) or
+ * the bound expires. The wait is always bounded: on timeout it rejects, and
+ * the caller (editInPlace) never edits after a failed settle — editing then
+ * would race the cancelled turn's straggler writes onto the surface. An
+ * unresolvable snapshot (session binding gone) cannot prove the settle, so it
+ * is waited out and rejected like a timeout, never treated as settled.
+ * @param snapshot - reads the session's current snapshot (undefined when the
+ *   binding is gone).
+ * @param options - timeout/interval/clock overrides.
+ * @returns resolution once settled; rejection on timeout.
+ */
+export declare function waitForTurnSettled(snapshot: () => TurnSettleSnapshot | undefined, options?: SettleWaitOptions): Promise<void>;
+//# sourceMappingURL=edit-in-place.d.ts.map

package/lib/types/client/edit-in-place.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit-in-place.d.ts","sourceRoot":"","sources":["../../../src/client/edit-in-place.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,wEAAwE;AACxE,MAAM,WAAW,gBAAgB;IAC/B,yCAAyC;IACzC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3B,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7B,2EAA2E;IAC3E,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,WAAW,CAAC,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAM1F;AAED,qEAAqE;AACrE,MAAM,WAAW,oBAAoB;IACnC,yCAAyC;IACzC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3B,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7B,8EAA8E;IAC9E,QAAQ,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CAC9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,oBAAoB,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAMlG;AAED;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAA;IAChB,YAAY,EAAE,SAAS,OAAO,EAAE,CAAA;IAChC,IAAI,EAAE;QACJ,QAAQ,EAAE;YACR,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;YAC5B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE;gBAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAAA;aAAE,CAAC,CAAA;SAC/E,CAAA;KACF,CAAA;CACF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,kBAAkB,GAAG,OAAO,CAOjE;AAED,2EAA2E;AAC3E,MAAM,WAAW,iBAAiB;IAChC,oEAAoE;IACpE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAA;IAClB,gCAAgC;IAChC,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,QAAQ,EAAE,MAAM,kBAAkB,GAAG,SAAS,EAC9C,OAAO,GAAE,iBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAcf"}

package/lib/types/client/edit-in-place.js

@@ -0,0 +1,97 @@
+/**
+ * Edit choreography shared by the shadowed renderers: cancel the running turn
+ * (waiting for it to settle so its teardown writes land before the
+ * replacement), then apply the in-place edit, which itself triggers the
+ * regeneration turn. Kept free of services so the unit tests drive it with
+ * stub verbs.
+ */
+/**
+ * Edit one user message in place: when the session has a running turn, cancel
+ * it first (it is writing into the span the edit is about to shadow) and wait
+ * for the settle, then apply the edit. A failed cancel rejects without
+ * editing; a failed or timed-out settle wait rejects without editing too —
+ * editing before the cancelled turn's teardown has landed would leak the
+ * straggler tool results outside the replacement's span. An idle session is
+ * never cancelled.
+ * @param steps - the cancel/waitIdle/edit verbs.
+ * @param running - whether the session has a running turn right now.
+ * @returns completion; failures reject at the failing step.
+ */
+export async function editInPlace(steps, running) {
+    if (running) {
+        await steps.cancel();
+        await steps.waitIdle();
+    }
+    await steps.edit();
+}
+/**
+ * Withdraw one user message: when the session has a running turn, cancel it
+ * first (it is writing into the span the withdrawal is about to shadow) and
+ * wait for the settle, then apply the withdrawal. A failed cancel rejects
+ * without withdrawing; a failed or timed-out settle wait rejects without
+ * withdrawing too — withdrawing before the cancelled turn's teardown has
+ * landed would leave straggler chunks/assistant writes outside the
+ * replacement's span. An idle session is never cancelled.
+ * @param steps - the cancel/waitIdle/withdraw verbs.
+ * @param running - whether the session has a running turn right now.
+ * @returns completion; failures reject at the failing step.
+ */
+export async function withdrawInPlace(steps, running) {
+    if (running) {
+        await steps.cancel();
+        await steps.waitIdle();
+    }
+    await steps.withdraw();
+}
+/**
+ * Whether the cancelled turn's teardown has fully landed in the session log.
+ * `running` flips false FIRST (host status push), the cancelled tool results
+ * persist after that, and the `turn/end` event lands last — an edit computed
+ * in between shadows a span that ends before those stragglers, leaving orphan
+ * tool messages in the model context (the model API then rejects the
+ * request). The authoritative settle signal is the latest turn's timeline
+ * location closing (turn/end is written after every result); `running` and
+ * `runningCalls` are earlier short-circuits. An empty turn order means the
+ * running turn's `turn/start` has not streamed in yet — not settled either.
+ * @param snapshot - the session's current conversation snapshot.
+ * @returns true only when every teardown write of the latest turn has landed.
+ */
+export function turnSettled(snapshot) {
+    if (snapshot.running)
+        return false;
+    if (snapshot.runningCalls.length > 0)
+        return false;
+    const order = snapshot.chat.timeline.turnOrder;
+    const last = order[order.length - 1];
+    if (last === undefined)
+        return false;
+    return snapshot.chat.timeline.turns.get(last)?.status === 'closed';
+}
+/**
+ * Poll until the cancelled turn has fully settled ({@link turnSettled}) or
+ * the bound expires. The wait is always bounded: on timeout it rejects, and
+ * the caller (editInPlace) never edits after a failed settle — editing then
+ * would race the cancelled turn's straggler writes onto the surface. An
+ * unresolvable snapshot (session binding gone) cannot prove the settle, so it
+ * is waited out and rejected like a timeout, never treated as settled.
+ * @param snapshot - reads the session's current snapshot (undefined when the
+ *   binding is gone).
+ * @param options - timeout/interval/clock overrides.
+ * @returns resolution once settled; rejection on timeout.
+ */
+export async function waitForTurnSettled(snapshot, options = {}) {
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? ((ms) => new Promise((resolve) => { setTimeout(resolve, ms); }));
+    const timeoutMs = options.timeoutMs ?? 5_000;
+    const intervalMs = options.intervalMs ?? 100;
+    const deadline = now() + timeoutMs;
+    for (;;) {
+        const current = snapshot();
+        if (current !== undefined && turnSettled(current))
+            return;
+        if (now() >= deadline) {
+            throw new Error('message-tools: timed out waiting for the cancelled turn to settle');
+        }
+        await sleep(intervalMs);
+    }
+}

package/lib/types/client/icons.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Package-owned icons matching the official outline-icon conventions (16×16
+ * viewBox, `fill="currentColor"` path geometry) for glyphs ui-primitives
+ * does not ship.
+ */
+/** Props of one package-owned icon. */
+export interface LocalIconProps {
+    /** Rendered edge length in px (icons are authored at 16). */
+    size?: number;
+    /** Optional composed class. */
+    className?: string;
+}
+/**
+ * Undo arrow (withdraw/restore), rotate-ccw style: a near-full circle arc
+ * (~290°, opening at the top) with a corner arrowhead at its left end
+ * pointing the counterclockwise direction. ui-primitives ships no undo/revert
+ * glyph, and its refresh glyph carries reload semantics, so this package
+ * draws its own.
+ * @param props - size and className.
+ * @returns the icon element.
+ */
+export declare const IconUndoOutline16: ({ size, className }: LocalIconProps) => import("react").JSX.Element;
+//# sourceMappingURL=icons.d.ts.map

package/lib/types/client/icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons.d.ts","sourceRoot":"","sources":["../../../src/client/icons.tsx"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,uCAAuC;AACvC,MAAM,WAAW,cAAc;IAC7B,6DAA6D;IAC7D,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,+BAA+B;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,wBAA8B,cAAc,gCAkBzE,CAAA"}

package/lib/types/client/icons.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Undo arrow (withdraw/restore), rotate-ccw style: a near-full circle arc
+ * (~290°, opening at the top) with a corner arrowhead at its left end
+ * pointing the counterclockwise direction. ui-primitives ships no undo/revert
+ * glyph, and its refresh glyph carries reload semantics, so this package
+ * draws its own.
+ * @param props - size and className.
+ * @returns the icon element.
+ */
+export const IconUndoOutline16 = ({ size = 16, className }) => (_jsxs("svg", { width: size, height: size, className: className, viewBox: "0 0 16 16", fill: "none", stroke: "currentColor", strokeWidth: 1.4, strokeLinecap: "round", strokeLinejoin: "round", xmlns: "http://www.w3.org/2000/svg", children: [_jsx("path", { d: "M2.2 8.7 A5.8 5.8 0 1 0 5.9 3.3 L2.6 6.6" }), _jsx("path", { d: "M2.6 2.4 V6.6 H6.2", fill: "none" })] }));

package/lib/types/client/index.d.ts

@@ -0,0 +1,39 @@
+/**
+ * message-tools client plugin, browser half. Shadows the official
+ * user-message renderer (`conversation.chat.node`, key 'user', priority -1)
+ * with a visual clone that adds edit/withdraw actions and a real
+ * model-switch chip in the editor (over ui-model-selection's shared
+ * per-session directory, read optionally through `ctx.get`), registers the
+ * withdrawal divider Definition so a landed withdrawal leaves a marker row,
+ * and installs the DOM hider that drops every chat row inside a withdrawn
+ * span (all node kinds, with probe-based degradation). The messageTools
+ * Remote is mounted here through the official `ctx.remote.$mount` channel, so
+ * the plugin distributes as an independent package with no edits to core
+ * packages. Composing this plugin out of cordis.yml removes every surface it
+ * adds.
+ * @module @khorsheed/dsh-client-message-tools/client
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import type { TypertRemoteNamespaceMap } from '@deepseek-ai/dsh-typert-protocol';
+/** The messageTools Remote namespace, as mounted by this plugin. */
+export type MessageToolsRemote = TypertRemoteNamespaceMap['messageTools'];
+/**
+ * Required services: slots, sessions, the remote channel, the scope-addressed
+ * conversation service, conversation node registration, and the copy.
+ * `remote.messageTools` is deliberately NOT an inject: this plugin both
+ * mounts the namespace (through `$mount` below) and consumes it, and the
+ * Cordis property proxy only resolves services declared in `inject` or
+ * provided by an ancestor fiber. Declaring it would deadlock the loader; the
+ * namespace is read back from the global store with `ctx.get` after the
+ * awaited mount.
+ */
+export declare const inject: string[];
+/**
+ * Client plugin body: mount the Remote, register the dictionaries, the
+ * withdrawal divider Definition, and the two `conversation.chat.node` entries
+ * (the divider row and the shadowed user renderer).
+ * @param ctx - client root context.
+ * @returns disposer unwinding the mounted Remote namespace.
+ */
+export declare function apply(ctx: ClientContext): Promise<() => Promise<void>>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,EAAE,aAAa,EAAa,MAAM,wCAAwC,CAAA;AAatF,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,kCAAkC,CAAA;AAahF,oEAAoE;AACpE,MAAM,MAAM,kBAAkB,GAAG,wBAAwB,CAAC,cAAc,CAAC,CAAA;AAczE;;;;;;;;;GASG;AACH,eAAO,MAAM,MAAM,UAAkF,CAAA;AAErG;;;;;;GAMG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAoJ5E"}

package/lib/types/client/index.js

@@ -0,0 +1,187 @@
+import messageToolsRemote from '@khorsheed/dsh-client-message-tools/remote';
+import { installDomHider } from './dom-hider.js';
+import { mergedDraft } from './backfill.js';
+import { editInPlace, waitForTurnSettled, withdrawInPlace } from './edit-in-place.js';
+import { en, zh } from './locales.js';
+import { editedMessageDefinition, restoredAssistantMessageDefinition, restoredMessageDefinition, withdrawnDividerDefinition, } from './withdrawn-node.js';
+import { UserMessageView } from './UserMessageView.js';
+import { RestoredMessageView } from './RestoredMessageView.js';
+import { WithdrawnDividerView } from './WithdrawnDividerView.js';
+/** Dictionary namespace owned by this plugin. */
+const NS = 'message-tools';
+/** Never-changing directory stub used when ui-model-selection is not composed; the chip is never rendered then. */
+const EMPTY_MODEL_DIRECTORY = {
+    getSnapshot: () => EMPTY_MODEL_DIRECTORY_STATE,
+    subscribe: () => () => { },
+};
+const EMPTY_MODEL_DIRECTORY_STATE = Object.freeze({
+    current: null, routable: null, groups: [], failures: [], status: 'idle', error: null,
+});
+/**
+ * Required services: slots, sessions, the remote channel, the scope-addressed
+ * conversation service, conversation node registration, and the copy.
+ * `remote.messageTools` is deliberately NOT an inject: this plugin both
+ * mounts the namespace (through `$mount` below) and consumes it, and the
+ * Cordis property proxy only resolves services declared in `inject` or
+ * provided by an ancestor fiber. Declaring it would deadlock the loader; the
+ * namespace is read back from the global store with `ctx.get` after the
+ * awaited mount.
+ */
+export const inject = ['slots', 'sessions', 'remote', 'conversation', 'conversationEvents', 'locale'];
+/**
+ * Client plugin body: mount the Remote, register the dictionaries, the
+ * withdrawal divider Definition, and the two `conversation.chat.node` entries
+ * (the divider row and the shadowed user renderer).
+ * @param ctx - client root context.
+ * @returns disposer unwinding the mounted Remote namespace.
+ */
+export async function apply(ctx) {
+    const disposers = [];
+    try {
+        disposers.push(await ctx.remote.$mount(messageToolsRemote));
+    }
+    catch (error) {
+        // A Remote already mounted by another composition fails loud at boot; the
+        // rest of the plugin still registers (the actions would answer an
+        // unmounted namespace with a typed RPC error, surfaced inline).
+        ctx.logger.error(error);
+    }
+    const remote = ctx.get('remote.messageTools');
+    const restore = async (sessionId, targetSeq) => {
+        const carried = await remote.restore({ sessionId, targetSeq });
+        if (!carried.ok)
+            throw new Error(`messageTools.restore transport: ${carried.error.code}`);
+        if (!carried.value.ok)
+            throw new Error(`messageTools.restore rejected: ${carried.value.error.code}`);
+    };
+    /**
+     * The draft-backfill path of the automatic post-withdrawal backfill:
+     * setDraft is the single public draft write path; the notice lands on this
+     * session's composer even across a session switch. Never sends.
+     */
+    const backfill = (sessionId, text) => {
+        const actx = ctx.sessions.scope(sessionId);
+        if (actx === undefined)
+            throw new Error(`message-tools: session "${sessionId}" resolved no scope`);
+        const conversation = actx.get('conversation');
+        if (conversation === undefined)
+            throw new Error('message-tools: conversation service unavailable');
+        const input = conversation.input.for(actx);
+        input.setDraft(mergedDraft(input.state.getSnapshot().draft, text));
+        input.notify('info', t('withdrawn.backfilled'));
+    };
+    ctx.effect(() => ctx.locale.register(NS, { zh, en }), 'message-tools: dictionaries');
+    const t = ctx.locale.bind(NS);
+    ctx.conversationEvents.register(withdrawnDividerDefinition);
+    ctx.conversationEvents.register(restoredMessageDefinition);
+    ctx.conversationEvents.register(restoredAssistantMessageDefinition);
+    ctx.conversationEvents.register(editedMessageDefinition);
+    ctx.effect(() => installDomHider(ctx), 'message-tools: dom hider');
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'message-tools-withdrawn',
+        locale: NS,
+        inject: (sessionId) => ({
+            restoreMessage: targetSeq => restore(sessionId, targetSeq),
+        }),
+    }, WithdrawnDividerView));
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({ name: 'conversation.chat.node', key: 'message-tools-restored-assistant', locale: NS }, RestoredMessageView));
+    // The slot is declared by ui-conversation, whose apply order relative to
+    // this plugin is unconstrained: register through slots.inject so the shadow
+    // waits for the declaration instead of crashing the loader entry at boot.
+    // 'user' and 'steering' share the official renderer upstream, so both keys
+    // get the same shadow here (an admitted steering message is an append
+    // surface user/message; edit/withdraw work identically).
+    const entryInject = (sessionId) => {
+        const actx = ctx.sessions.scope(sessionId);
+        if (actx === undefined)
+            throw new Error(`message-tools: session "${sessionId}" resolved no scope`);
+        const conversation = actx.get('conversation');
+        if (conversation === undefined)
+            throw new Error('message-tools: conversation service unavailable');
+        // The model chip rides ui-model-selection's shared per-session
+        // directory — an optional service (ctx.get, never an inject edge, so a
+        // composition without it degrades to no chip instead of a loader wait).
+        const models = ctx.get('modelDirectories');
+        const directory = models === undefined || ctx.sessions.subagentAddress(sessionId) !== undefined
+            ? undefined
+            : models.directoryFor(sessionId);
+        const withdraw = async (targetSeq) => {
+            const carried = await remote.withdraw({ sessionId, targetSeq });
+            if (!carried.ok)
+                throw new Error(`messageTools.withdraw transport: ${carried.error.code}`);
+            if (!carried.value.ok)
+                throw new Error(`messageTools.withdraw rejected: ${carried.value.error.code}`);
+        };
+        const edit = async (targetSeq, text) => {
+            const carried = await remote.edit({ sessionId, targetSeq, text });
+            if (!carried.ok)
+                throw new Error(`messageTools.edit transport: ${carried.error.code}`);
+            if (!carried.value.ok)
+                throw new Error(`messageTools.edit rejected: ${carried.value.error.code}`);
+        };
+        // After a cancel, `running` flips false BEFORE the turn's teardown
+        // finishes landing (cancelled tool results persist after the flip,
+        // turn/end last); a replacement's span must cover all of it, so wait
+        // for the turn to actually close. Bounded: a turn that never settles
+        // rejects instead of letting the edit/withdraw race the stragglers.
+        const waitIdle = () => waitForTurnSettled(() => ctx.sessions.binding(sessionId)?.session.getSnapshot());
+        return {
+            editMessage: (targetSeq, text) => editInPlace({
+                cancel: () => conversation.cancel(),
+                waitIdle,
+                edit: () => edit(targetSeq, text),
+            }, ctx.sessions.binding(sessionId)?.session.getSnapshot().running === true),
+            withdrawMessage: targetSeq => withdrawInPlace({
+                cancel: () => conversation.cancel(),
+                waitIdle,
+                withdraw: () => withdraw(targetSeq),
+            }, ctx.sessions.binding(sessionId)?.session.getSnapshot().running === true),
+            backfillDraft: (text) => { backfill(sessionId, text); },
+            modelsAvailable: directory !== undefined,
+            loadModels: () => {
+                // Load failures surface on the directory store itself.
+                directory?.load().catch(() => undefined);
+            },
+            selectModel: selection => directory === undefined
+                ? Promise.resolve(false)
+                : directory.select(selection).then(() => true, () => false),
+            hooks: {
+                modelDirectory: directory === undefined ? EMPTY_MODEL_DIRECTORY : directory.store,
+            },
+        };
+    };
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'user',
+        priority: -1,
+        locale: NS,
+        inject: entryInject,
+    }, UserMessageView));
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'steering',
+        priority: -1,
+        locale: NS,
+        inject: entryInject,
+    }, UserMessageView));
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'message-tools-edited',
+        locale: NS,
+        inject: entryInject,
+    }, UserMessageView));
+    // Restored user-message replays get the same full renderer (bubble plus the
+    // copy/edit/withdraw action row): a restored row edits and withdraws like
+    // the message it replays.
+    ctx.slots.inject('conversation.chat.node', () => ctx.slots.register({
+        name: 'conversation.chat.node',
+        key: 'message-tools-restored',
+        locale: NS,
+        inject: entryInject,
+    }, UserMessageView));
+    return async () => {
+        for (const dispose of disposers.reverse())
+            await dispose();
+    };
+}

package/lib/types/client/locales.d.ts

@@ -0,0 +1,74 @@
+/** `message-tools` namespace dictionaries. */
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export declare const zh: {
+    'action.withdraw': string;
+    'editor.aria': string;
+    'editor.placeholder': string;
+    'editor.save': string;
+    'withdraw.title': string;
+    'withdraw.description': string;
+    'withdraw.acknowledge': string;
+    'withdraw.confirm': string;
+    'withdrawn.divider': string;
+    'withdrawn.expand': string;
+    'withdrawn.empty': string;
+    'withdrawn.entryUser': string;
+    'withdrawn.entryAssistant': string;
+    'withdrawn.restore': string;
+    'withdrawn.backfilled': string;
+    'withdrawn.restored': string;
+    'restored.assistant': string;
+    'withdrawn.restoreFailed': string;
+    'error.edit': string;
+    'edited.badge': string;
+    'error.withdraw': string;
+    'model.aria': string;
+    'model.menuAria': string;
+    'model.effort': string;
+    'model.providerDefault': string;
+    'model.empty': string;
+    'model.selectFailed': string;
+    'message.extraBlock': string;
+    'json.truncated': string;
+};
+/** The message-tools namespace key union. */
+export type MessageToolsKey = keyof typeof zh;
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        /** The user-message edit/withdraw controls' copy. */
+        'message-tools': MessageToolsKey;
+    }
+}
+/** English dictionary, checked complete against the zh key set. */
+export declare const en: {
+    'action.withdraw': string;
+    'editor.aria': string;
+    'editor.placeholder': string;
+    'editor.save': string;
+    'withdraw.title': string;
+    'withdraw.description': string;
+    'withdraw.acknowledge': string;
+    'withdraw.confirm': string;
+    'withdrawn.divider': string;
+    'withdrawn.expand': string;
+    'withdrawn.empty': string;
+    'withdrawn.entryUser': string;
+    'withdrawn.entryAssistant': string;
+    'withdrawn.restore': string;
+    'withdrawn.backfilled': string;
+    'withdrawn.restored': string;
+    'restored.assistant': string;
+    'withdrawn.restoreFailed': string;
+    'error.edit': string;
+    'edited.badge': string;
+    'error.withdraw': string;
+    'model.aria': string;
+    'model.menuAria': string;
+    'model.effort': string;
+    'model.providerDefault': string;
+    'model.empty': string;
+    'model.selectFailed': string;
+    'message.extraBlock': string;
+    'json.truncated': string;
+};
+//# sourceMappingURL=locales.d.ts.map

package/lib/types/client/locales.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locales.d.ts","sourceRoot":"","sources":["../../../src/client/locales.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAE9C,mEAAmE;AACnE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BmB,CAAA;AAElC,6CAA6C;AAC7C,MAAM,MAAM,eAAe,GAAG,MAAM,OAAO,EAAE,CAAA;AAE7C,OAAO,QAAQ,kCAAkC,CAAC;IAChD,UAAU,kBAAkB;QAC1B,qDAAqD;QACrD,eAAe,EAAE,eAAe,CAAA;KACjC;CACF;AAED,mEAAmE;AACnE,eAAO,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8B4B,CAAA"}

package/lib/types/client/locales.js

@@ -0,0 +1,65 @@
+/** `message-tools` namespace dictionaries. */
+/** Simplified Chinese dictionary (the key-set source of truth). */
+export const zh = {
+    'action.withdraw': '撤回',
+    'editor.aria': '编辑消息',
+    'editor.placeholder': '编辑消息…',
+    'editor.save': '保存并重新发送',
+    'withdraw.title': '撤回这条消息？',
+    'withdraw.description': '撤回后，这条消息及其后的所有内容都会对模型隐藏；原文会回填到输入框，可再从撤回分隔线恢复到对话末尾。',
+    'withdraw.acknowledge': '我已了解撤回的影响',
+    'withdraw.confirm': '确认撤回',
+    'withdrawn.divider': '已撤回 {count} 条消息',
+    'withdrawn.expand': '展开查看撤回内容',
+    'withdrawn.empty': '撤回的内容不在当前已加载的历史中',
+    'withdrawn.entryUser': '用户消息原文',
+    'withdrawn.entryAssistant': '助手回复摘要',
+    'withdrawn.restore': '恢复到对话末尾',
+    'withdrawn.backfilled': '已回填到输入框，可编辑后发送',
+    'withdrawn.restored': '已恢复',
+    'restored.assistant': '已恢复 · 助手回复',
+    'withdrawn.restoreFailed': '恢复失败，请重试',
+    'error.edit': '编辑失败，请重试',
+    'edited.badge': '已编辑',
+    'error.withdraw': '撤回失败，请重试',
+    'model.aria': '切换模型，当前 {model}',
+    'model.menuAria': '模型与推理等级',
+    'model.effort': '推理等级',
+    'model.providerDefault': '默认',
+    'model.empty': '暂无可用模型',
+    'model.selectFailed': '模型切换失败',
+    'message.extraBlock': '附加内容块',
+    'json.truncated': '… 已截断，共 {total} 字符',
+};
+/** English dictionary, checked complete against the zh key set. */
+export const en = {
+    'action.withdraw': 'Withdraw',
+    'editor.aria': 'Edit message',
+    'editor.placeholder': 'Edit the message…',
+    'editor.save': 'Save and resend',
+    'withdraw.title': 'Withdraw this message?',
+    'withdraw.description': 'Once withdrawn, this message and everything after it will be hidden from the model; its text is backfilled into the composer, and it can be restored to the conversation tail from the withdrawal divider.',
+    'withdraw.acknowledge': 'I understand the effect of withdrawal',
+    'withdraw.confirm': 'Confirm withdrawal',
+    'withdrawn.divider': 'Withdrawn {count} messages',
+    'withdrawn.expand': 'Expand the withdrawn content',
+    'withdrawn.empty': 'The withdrawn content is outside the loaded history',
+    'withdrawn.entryUser': 'Original user message',
+    'withdrawn.entryAssistant': 'Assistant reply summary',
+    'withdrawn.restore': 'Restore to the end of the conversation',
+    'withdrawn.backfilled': 'Backfilled into the composer; edit and send',
+    'withdrawn.restored': 'Restored',
+    'restored.assistant': 'Restored · assistant reply',
+    'withdrawn.restoreFailed': 'Could not restore; please retry',
+    'error.edit': 'Could not apply the edit; please retry',
+    'edited.badge': 'Edited',
+    'error.withdraw': 'Could not withdraw the message; please retry',
+    'model.aria': 'Switch model, current {model}',
+    'model.menuAria': 'Model and reasoning effort',
+    'model.effort': 'Reasoning effort',
+    'model.providerDefault': 'Provider default',
+    'model.empty': 'No models available',
+    'model.selectFailed': 'Could not switch model',
+    'message.extraBlock': 'Extra content block',
+    'json.truncated': '… truncated, {total} characters total',
+};