@khorsheed/dsh-mobile 0.1.0

package/lib/types/client/composerFocus.js

@@ -0,0 +1,41 @@
+/** rc1 has no composer autofocus option. Guard navigation focus through public
+ * DOM events; never replace Lexical, its focus method, selection, or draft. */
+export class ComposerFocus {
+    doc;
+    active;
+    waiting = true;
+    constructor(doc, active) {
+        this.doc = doc;
+        this.active = active;
+        doc.addEventListener('focusin', this.focus, true);
+        doc.addEventListener('pointerdown', this.pointer, true);
+        doc.addEventListener('keydown', this.key, true);
+    }
+    arm = () => {
+        this.waiting = true;
+        const el = this.doc.activeElement;
+        if (this.active() && el instanceof HTMLElement && this.isEditor(el))
+            el.blur();
+    };
+    isEditor(el) {
+        return !!el.closest('[data-mobile-frame] [data-composer-card] [contenteditable="true"]');
+    }
+    focus = (event) => {
+        if (this.active() && this.waiting && event.target instanceof HTMLElement && this.isEditor(event.target))
+            event.target.blur();
+    };
+    pointer = (event) => {
+        // Explicit composer taps and message actions (e.g. edit) may focus input.
+        if (event.target instanceof Element && event.target.closest('[data-mobile-frame] :is([data-composer-card], [data-conversation-scroll])'))
+            this.waiting = false;
+    };
+    key = (event) => {
+        if (event.key === 'Tab')
+            this.waiting = false;
+    };
+    dispose() {
+        this.doc.removeEventListener('focusin', this.focus, true);
+        this.doc.removeEventListener('pointerdown', this.pointer, true);
+        this.doc.removeEventListener('keydown', this.key, true);
+    }
+}

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

@@ -0,0 +1,17 @@
+import { type MobileDirectoryListing } from '../protocol.ts';
+/** One pending path choice shared by every mobile caller of the Host picker. */
+export declare class MobileDirectory {
+    private pending;
+    private listeners;
+    readonly getSnapshot: () => boolean;
+    readonly subscribe: (listener: () => void) => () => void;
+    readonly pick: () => Promise<string | null>;
+    readonly finish: (path: string | null) => void;
+    readonly list: (path: string | undefined, signal: AbortSignal) => Promise<MobileDirectoryListing>;
+}
+/** Checked public-method fallback until Host offers a pure path-selection UI slot.
+ * Scoped to this browser; preserve desktop dispatch and restore only our own wrapper. */
+export declare function installMobileDirectoryPicker(owner: {
+    pickDirectory(): Promise<string | null>;
+}, directory: MobileDirectory, active: () => boolean): () => void;
+//# sourceMappingURL=directory.d.ts.map

package/lib/types/client/directory.js

@@ -0,0 +1,54 @@
+import { DIRECTORY_PATH } from '../protocol.js';
+/** One pending path choice shared by every mobile caller of the Host picker. */
+export class MobileDirectory {
+    pending;
+    listeners = new Set();
+    getSnapshot = () => !!this.pending;
+    subscribe = (listener) => { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; };
+    pick = () => {
+        if (!this.pending) {
+            let resolve;
+            const promise = new Promise(done => { resolve = done; });
+            this.pending = { promise, resolve };
+            for (const listener of this.listeners)
+                listener();
+        }
+        return this.pending.promise;
+    };
+    finish = (path) => {
+        const pending = this.pending;
+        this.pending = undefined;
+        pending?.resolve(path);
+        for (const listener of this.listeners)
+            listener();
+    };
+    list = async (path, signal) => {
+        const response = await fetch(`${DIRECTORY_PATH}${path === undefined ? '' : `?path=${encodeURIComponent(path)}`}`, { signal, credentials: 'same-origin', cache: 'no-store' });
+        if (!response.ok)
+            throw new Error('directory-unavailable');
+        return response.json();
+    };
+}
+/** Checked public-method fallback until Host offers a pure path-selection UI slot.
+ * Scoped to this browser; preserve desktop dispatch and restore only our own wrapper. */
+export function installMobileDirectoryPicker(owner, directory, active) {
+    const descriptor = Object.getOwnPropertyDescriptor(owner, 'pickDirectory');
+    const original = owner.pickDirectory;
+    const wrapped = () => active() ? directory.pick() : original.call(owner);
+    // A future read-only facade must not prevent the rest of mobile from loading.
+    try {
+        owner.pickDirectory = wrapped;
+    }
+    catch {
+        return () => { directory.finish(null); };
+    }
+    return () => {
+        directory.finish(null);
+        if (owner.pickDirectory !== wrapped)
+            return;
+        if (descriptor)
+            Object.defineProperty(owner, 'pickDirectory', descriptor);
+        else
+            Reflect.deleteProperty(owner, 'pickDirectory');
+    };
+}

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

@@ -0,0 +1,4 @@
+/** Resume a stale official follow generation, preserving live reply baselines.
+ * Brief interruptions and duplicate native/browser signals leave healthy streams alone. */
+export declare function installForegroundRecovery(win: Window, reconnect: () => void, getState?: () => string | undefined): () => void;
+//# sourceMappingURL=foreground.d.ts.map

package/lib/types/client/foreground.js

@@ -0,0 +1,47 @@
+/** Resume a stale official follow generation, preserving live reply baselines.
+ * Brief interruptions and duplicate native/browser signals leave healthy streams alone. */
+export function installForegroundRecovery(win, reconnect, getState = () => undefined) {
+    let hiddenAt = win.document.visibilityState === 'hidden' ? Date.now() : undefined;
+    let lastSignalAt = Date.now(), lastReconnectAt = -Infinity;
+    let timer, needsRecovery = false;
+    const resume = (awayMs) => {
+        if (win.document.visibilityState === 'hidden' || win.navigator.onLine === false)
+            return;
+        const state = getState();
+        needsRecovery ||= awayMs >= 5000 || (state !== 'connected' && state !== 'connecting');
+        lastSignalAt = Date.now();
+        if (timer !== undefined)
+            win.clearTimeout(timer);
+        timer = win.setTimeout(() => {
+            timer = undefined;
+            if (needsRecovery && Date.now() - lastReconnectAt >= 1000) {
+                lastReconnectAt = Date.now();
+                reconnect();
+            }
+            needsRecovery = false;
+        }, 150);
+    };
+    const native = () => resume(Date.now() - (hiddenAt ?? lastSignalAt));
+    const visibility = () => {
+        if (win.document.visibilityState === 'hidden') {
+            hiddenAt = Date.now();
+            needsRecovery = false;
+            if (timer !== undefined)
+                win.clearTimeout(timer);
+            timer = undefined;
+            return;
+        }
+        if (hiddenAt !== undefined) {
+            const elapsed = Date.now() - hiddenAt;
+            hiddenAt = undefined;
+            resume(elapsed);
+        }
+    };
+    const page = (event) => { if (event.persisted)
+        resume(Infinity); };
+    win.document.addEventListener('visibilitychange', visibility);
+    win.addEventListener('pageshow', page);
+    win.addEventListener('dsh-mobile-foreground', native);
+    return () => { if (timer !== undefined)
+        win.clearTimeout(timer); win.document.removeEventListener('visibilitychange', visibility); win.removeEventListener('pageshow', page); win.removeEventListener('dsh-mobile-foreground', native); };
+}

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

@@ -0,0 +1,4 @@
+/** Horizontal navigation never claims text selection, editors or nested horizontal content. */
+export declare function navigationSwipe(dx: number, dy: number, width: number): 'open' | 'close' | undefined;
+export declare function installNavigationGestures(doc: Document, change: (open: boolean) => void, closeSidebar?: () => void): () => void;
+//# sourceMappingURL=gestures.d.ts.map

package/lib/types/client/gestures.js

@@ -0,0 +1,118 @@
+/** Horizontal navigation never claims text selection, editors or nested horizontal content. */
+export function navigationSwipe(dx, dy, width) {
+    if (Math.abs(dx) < Math.min(72, width * .18) || Math.abs(dx) < Math.abs(dy) * 1.6)
+        return;
+    return dx > 0 ? 'open' : 'close';
+}
+export function installNavigationGestures(doc, change, closeSidebar) {
+    let start, suppressClickUntil = 0, suppressClickTarget, animation;
+    const resetDrag = () => {
+        start?.panel?.element.style.removeProperty('transform');
+        doc.documentElement.removeAttribute('data-mobile-gesture');
+        doc.documentElement.style.removeProperty('--mobile-drag-offset');
+    };
+    const blocked = 'input,textarea,[contenteditable],select,pre,code,[role=dialog],[role=menu],[role=slider],[role=switch],[role=checkbox],[data-mobile-tools-dialog],[data-mobile-dialog]';
+    const down = (event) => {
+        resetDrag();
+        start = undefined;
+        suppressClickUntil = 0;
+        suppressClickTarget = undefined;
+        if (animation || event.touches.length !== 1 || doc.querySelector('dialog[open],[role=dialog],[role=menu]'))
+            return;
+        const target = event.target;
+        if (target.closest(blocked) || doc.getSelection()?.toString())
+            return;
+        // List rows are navigation surfaces: a tap opens, a horizontal drag dismisses.
+        // All other buttons keep their existing touch behavior.
+        if (target.closest('button,a') && !target.closest('[data-mobile-session],[data-mobile-workspace-group],[data-mobile-peek-close],[data-slot=sidebar]'))
+            return;
+        for (let node = target; node && node !== doc.body; node = node.parentElement) {
+            if (node.scrollWidth > node.clientWidth + 4 && /auto|scroll/.test(doc.defaultView.getComputedStyle(node).overflowX))
+                return;
+        }
+        const viewport = doc.documentElement.clientWidth || doc.defaultView.innerWidth;
+        if (viewport >= 960)
+            return; // A pinned two-column layout is not a drawer.
+        const right = target.closest('[data-sidebar-right-panel][data-sidebar-right-open]') ?? undefined;
+        if (right && !right.querySelector('[data-sidebar-right-toggle]'))
+            return;
+        const sidebar = closeSidebar ? target.closest('[data-slot=sidebar]')?.parentElement : undefined;
+        const panel = right ? { element: right, side: 'right', close: () => right.querySelector('[data-sidebar-right-toggle]')?.click() } : sidebar ? { element: sidebar, side: 'left', close: closeSidebar } : undefined;
+        const width = panel ? panel.element.getBoundingClientRect().width || viewport : Math.min(viewport * .84, 380);
+        start = { target: target.closest('button,a') ?? target, x: event.touches[0].clientX, y: event.touches[0].clientY, width, initial: doc.documentElement.hasAttribute('data-mobile-library-open') ? width : 0, ...(panel ? { panel } : {}), dragged: false };
+    };
+    const move = (event) => {
+        if (!start || event.touches.length !== 1) {
+            resetDrag();
+            start = undefined;
+            return;
+        }
+        const dx = event.touches[0].clientX - start.x, dy = event.touches[0].clientY - start.y;
+        if (!start.dragged && Math.abs(dy) > 12 && Math.abs(dy) > Math.abs(dx)) {
+            resetDrag();
+            start = undefined;
+            return;
+        }
+        if (!start.dragged && (Math.abs(dx) <= 12 || Math.abs(dx) <= Math.abs(dy) * 1.6))
+            return;
+        if (start.panel) {
+            const direction = start.panel.side === 'right' ? 1 : -1;
+            if (!start.dragged && dx * direction < 0)
+                return;
+            start.panel.element.style.transform = `translate3d(${direction * Math.max(0, dx * direction)}px,0,0)`;
+        }
+        else {
+            if (!start.dragged && (start.initial === 0 && dx < 0 || start.initial > 0 && dx > 0))
+                return;
+            doc.documentElement.setAttribute('data-mobile-gesture', '');
+            doc.documentElement.style.setProperty('--mobile-drag-offset', `${Math.max(0, Math.min(start.width, start.initial + dx))}px`);
+        }
+        start.dragged = true;
+        if (event.cancelable)
+            event.preventDefault();
+    };
+    const up = (event) => {
+        const from = start, point = event.changedTouches[0];
+        if (!from || !point) {
+            resetDrag();
+            start = undefined;
+            return;
+        }
+        const dx = point.clientX - from.x, dy = point.clientY - from.y;
+        const result = from.dragged ? navigationSwipe(dx, dy, from.width) : undefined;
+        if (from.dragged) {
+            suppressClickUntil = Date.now() + 500;
+            suppressClickTarget = from.target;
+        }
+        if (from.panel && from.dragged) {
+            const owner = from.panel, panel = owner.element, direction = owner.side === 'right' ? 1 : -1;
+            const close = result === (owner.side === 'right' ? 'open' : 'close');
+            const finish = () => { animation = undefined; panel.style.removeProperty('transform'); if (close && panel.isConnected)
+                owner.close(); };
+            if (panel.animate && !doc.defaultView?.matchMedia('(prefers-reduced-motion: reduce)').matches) {
+                animation = panel.animate([{ transform: `translateX(${direction * Math.max(0, dx * direction)}px)` }, { transform: `translateX(${close ? direction * from.width : 0}px)` }], { duration: 180, easing: 'cubic-bezier(.2,.8,.2,1)' });
+                animation.onfinish = finish;
+            }
+            else
+                finish();
+        }
+        resetDrag();
+        start = undefined;
+        if (!from.panel && result)
+            change(result === 'open');
+    };
+    const cancel = () => { resetDrag(); start = undefined; };
+    const click = (event) => {
+        if (event.detail !== 0 && Date.now() < suppressClickUntil && event.target instanceof Node && (suppressClickTarget?.contains(event.target) || event.target.contains(suppressClickTarget ?? null))) {
+            event.preventDefault();
+            event.stopImmediatePropagation();
+            suppressClickUntil = 0;
+        }
+    };
+    doc.addEventListener('touchstart', down, { passive: true });
+    doc.addEventListener('touchmove', move, { passive: false });
+    doc.addEventListener('touchend', up);
+    doc.addEventListener('touchcancel', cancel);
+    doc.addEventListener('click', click, true);
+    return () => { cancel(); animation?.cancel(); doc.removeEventListener('touchstart', down); doc.removeEventListener('touchmove', move); doc.removeEventListener('touchend', up); doc.removeEventListener('touchcancel', cancel); doc.removeEventListener('click', click, true); };
+}

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

@@ -0,0 +1,20 @@
+import type { Context } from '@deepseek-ai/cordis';
+declare global {
+    interface Window {
+        __DSH_MOBILE_SHELL__?: {
+            bridgeVersion: number;
+            capabilities?: readonly string[];
+        };
+        webkit?: {
+            messageHandlers?: {
+                dshMobile?: {
+                    postMessage(value: unknown): void;
+                };
+            };
+        };
+    }
+}
+export declare const inject: string[];
+/** One browser-owned presentation; no Host preference or sibling plugin is changed. */
+export declare function apply(ctx: Context): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.js

@@ -0,0 +1,144 @@
+import { ConnectPhone } from './ConnectPhone.js';
+import { BRIDGE_VERSION, MOBILE_VERSION } from '../protocol.js';
+import { MobilePresentation } from './presentation.js';
+import { DirectoryFlow, MobileDirectoryOverlay } from './DirectoryFlow.js';
+import { MobileDirectory, installMobileDirectoryPicker } from './directory.js';
+import { MobileNavigation, mainSessionId } from './navigation.js';
+import { MobileWelcome } from './MobileSeats.js';
+import { MobileSubmissionFocus } from './SubmissionFocus.js';
+import { MobileTools } from './MobileTools.js';
+import { MobileChrome } from './MobileChrome.js';
+import { MobileQueue } from './MobileQueue.js';
+import { MobileRooms } from './rooms.js';
+import { MessageMenu } from './messageMenu.js';
+import { installForegroundRecovery } from './foreground.js';
+import { NS, en, zh } from './locales.js';
+export const inject = ['slots', 'locale', 'layout', 'connection'];
+/** One browser-owned presentation; no Host preference or sibling plugin is changed. */
+export function apply(ctx) {
+    ctx.effect(() => ctx.locale.register(NS, { en, zh }), 'mobile: dictionaries');
+    ctx.slots.inject('settings.section', () => ctx.slots.register({
+        name: 'settings.section', id: 'mobile-connect', order: 25, label: () => ctx.locale.bind(NS)('connectPhone'), locale: NS,
+    }, ConnectPhone));
+    const connection = ctx.get('connection');
+    const rooms = new MobileRooms(() => ctx.get('remote.room'));
+    ctx.effect(() => () => rooms.dispose(), 'mobile: room presentation');
+    const messages = new MessageMenu(document);
+    ctx.effect(() => () => messages.dispose(), 'mobile: message actions');
+    const navigation = new MobileNavigation();
+    const directory = new MobileDirectory();
+    const presentation = new MobilePresentation(window, window.__DSH_MOBILE_SHELL__?.bridgeVersion === BRIDGE_VERSION);
+    ctx.inject(['sessions', 'workspaces', 'uiWorkspace'], scoped => {
+        navigation.set({ sessions: scoped.sessions, workspaces: scoped.workspaces, workspace: scoped.uiWorkspace });
+        scoped.effect(() => installMobileDirectoryPicker(scoped.uiWorkspace, directory, () => presentation.getSnapshot().active), 'mobile: path picker');
+        scoped.effect(() => () => { navigation.set(undefined); }, 'mobile: optional navigation');
+    });
+    ctx.effect(() => { const off = presentation.subscribe(() => { if (!presentation.getSnapshot().active)
+        directory.finish(null); }); return () => { off(); directory.finish(null); }; }, 'mobile: pending directory');
+    ctx.slots.inject('shell.overlay', () => ctx.slots.register({ name: 'shell.overlay', id: 'mobile-directory', locale: NS, inject: () => ({ directory, navigation }) }, MobileDirectoryOverlay));
+    ctx.effect(() => () => { presentation.dispose(); }, 'mobile: presentation');
+    ctx.effect(() => {
+        let remove;
+        const sync = () => {
+            if (presentation.getSnapshot().active)
+                remove ??= installForegroundRecovery(window, () => connection.reconnect(), () => connection.state.getSnapshot());
+            else {
+                remove?.();
+                remove = undefined;
+            }
+        };
+        sync();
+        const unsubscribe = presentation.subscribe(sync);
+        return () => { unsubscribe(); remove?.(); };
+    }, 'mobile: foreground reconnect');
+    ctx.slots.inject('shell.overlay', () => ctx.slots.register({
+        name: 'shell.overlay', id: 'mobile-navigation', locale: NS,
+        inject: () => ({ presentation, connection, navigation, rooms, toggleSidebar: () => { ctx.layout.toggleSidebar(); } }),
+    }, MobileChrome));
+    for (const name of ['conversation.input.dock', 'conversation.session.header.actions']) {
+        ctx.slots.inject(name, () => ctx.slots.register({ name, id: 'mobile-send-focus' }, MobileSubmissionFocus));
+    }
+    // Room's first asynchronous cache fill does not bump its composer slot in
+    // this revision. A declining mobile entry refreshes the public election;
+    // the original Room/approval/local-agent entries still decide the winner.
+    ctx.slots.inject('conversation.composer', () => {
+        let remove;
+        let timer;
+        const refresh = () => {
+            const list = navigation.getSnapshot()?.sessions.list.getSnapshot();
+            const current = list === undefined ? undefined : mainSessionId(list);
+            if (!presentation.getSnapshot().active || !current || !rooms.get(current))
+                return;
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+                remove?.();
+                remove = ctx.slots.register({ name: 'conversation.composer', priority: 10000, select: () => null }, () => null);
+            }, 300);
+        };
+        const unsubscribe = rooms.subscribe(refresh);
+        return () => { unsubscribe(); clearTimeout(timer); remove?.(); };
+    });
+    ctx.slots.inject('conversation.session.header.actions', () => ctx.slots.register({
+        name: 'conversation.session.header.actions', id: 'mobile-room-queue', locale: NS,
+        inject: sessionId => {
+            const conversation = ctx.get('sessions')?.scope(sessionId)?.get('conversation');
+            return conversation ? { updateQueue: conversation.updateQueue.bind(conversation) } : {};
+        },
+    }, MobileQueue));
+    // Contribute through existing seats; no foreign child-slot ownership is claimed.
+    ctx.slots.inject('conversation.hero.brand.mark', () => {
+        let remove;
+        const sync = () => {
+            if (presentation.getSnapshot().active)
+                remove ??= ctx.slots.register({ name: 'conversation.hero.brand.mark', priority: -100, locale: NS }, MobileWelcome);
+            else {
+                remove?.();
+                remove = undefined;
+            }
+        };
+        sync();
+        const unsubscribe = presentation.subscribe(sync);
+        return () => { unsubscribe(); remove?.(); };
+    });
+    ctx.slots.inject('conversation.input.left', () => {
+        let remove;
+        const sync = () => {
+            if (presentation.getSnapshot().active)
+                remove ??= ctx.slots.register({ name: 'conversation.input.left', id: 'mobile-input-tools', order: -100, locale: NS, inject: () => ({ rooms }) }, MobileTools);
+            else {
+                remove?.();
+                remove = undefined;
+            }
+        };
+        sync();
+        const unsubscribe = presentation.subscribe(sync);
+        return () => { unsubscribe(); remove?.(); };
+    });
+    // Shadow only these public flow slots while this client is in mobile mode.
+    for (const name of ['conversation.hero.workspace.directoryFlow', 'sidebar.workspaces.directoryFlow']) {
+        ctx.slots.inject(name, () => {
+            let remove;
+            const sync = () => {
+                if (presentation.getSnapshot().active) {
+                    remove ??= ctx.slots.register({ name, priority: -100, locale: NS, inject: () => ({ directory, navigation }) }, DirectoryFlow);
+                }
+                else {
+                    remove?.();
+                    remove = undefined;
+                }
+            };
+            sync();
+            const unsubscribe = presentation.subscribe(sync);
+            return () => { unsubscribe(); remove?.(); };
+        });
+    }
+    const post = (type) => {
+        if (window.__DSH_MOBILE_SHELL__?.bridgeVersion !== BRIDGE_VERSION)
+            return;
+        window.webkit?.messageHandlers?.dshMobile?.postMessage({ type, bridgeVersion: BRIDGE_VERSION, mobileVersion: MOBILE_VERSION, layout: presentation.getSnapshot(), navigation: !!navigation.getSnapshot(), anchors: { root: document.querySelectorAll('[data-slot="root"]').length, overlay: document.querySelectorAll('[data-shell-overlay]').length, main: document.querySelectorAll('[data-slot="main"]').length, sidebar: document.querySelectorAll('[data-slot="sidebar"]').length } });
+    };
+    post('ready');
+    ctx.effect(() => presentation.subscribe(() => post('ready')), 'mobile: layout availability');
+    ctx.effect(() => navigation.subscribe(() => post('ready')), 'mobile: navigation availability');
+    ctx.effect(() => () => { post('unloaded'); }, 'mobile: shell availability');
+}

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

@@ -0,0 +1,145 @@
+/** Copy for controls owned by mobile; all conversation copy stays with its owner. */
+export declare const NS = "mobile";
+export declare const en: {
+    readonly connectPhone: "Connect phone";
+    readonly connectIntro: "Continue your conversations in DSH Mobile.";
+    readonly connectQR: "Scan with DSH Mobile to sign in";
+    readonly connectGenerate: "Show login QR code";
+    readonly connectHide: "Hide QR code";
+    readonly connectConceal: "Hidden automatically after 2 minutes or when you leave this page.";
+    readonly connectStepOpen: "Open DSH Mobile on your iPhone.";
+    readonly connectStepScan: "Go to Connection Settings → Scan to connect.";
+    readonly connectStepConfirm: "Scan this code, check the host address, then confirm the connection.";
+    readonly connectPrivacy: "This QR code grants access to this host. Keep it private. Hiding the code does not revoke the official login link; it remains valid until the host process restarts.";
+    readonly connectNetwork: "Keep the computer and its HTTPS entry online. Scanning reconnects the App; it cannot repair a disconnected tunnel.";
+    readonly connectSetup: "The operator must configure a reachable HTTPS origin using mobile.publicOrigin or DSH_MOBILE_PUBLIC_ORIGIN, and add its hostname to the host trusted hosts.";
+    readonly connectUntrusted: "The configured address is not trusted by this host. Update --trusted-host and restart the host before generating a code.";
+    readonly connectUnsupported: "This host version cannot provide official login links. Update the supported host/plugin combination.";
+    readonly connectError: "Could not load the connection information. Check the connection and retry.";
+    readonly connectLoading: "Loading connection information…";
+    readonly directoryManual: 'Enter a path';
+    readonly directoryTitle: 'Choose working directory';
+    readonly directoryHint: 'Select a folder on your computer.';
+    readonly directoryComputer: 'Browse computer';
+    readonly directoryNoSaved: 'No saved workspaces yet. Browse your computer to choose one.';
+    readonly directoryGo: 'Go';
+    readonly directoryParent: 'Parent folder';
+    readonly directoryHidden: 'Hidden folders';
+    readonly directoryLoading: 'Loading folders…';
+    readonly directoryError: 'Could not read this folder. Check the path, permissions and connection.';
+    readonly directoryRetry: 'Retry';
+    readonly directorySearch: 'Filter folders';
+    readonly directoryEmpty: 'No subfolders.';
+    readonly directoryTruncated: 'This listing is limited. Enter a full path to open another folder.';
+    readonly directorySelect: 'Use this directory';
+    readonly renameSession: 'Rename session';
+    readonly sessionTitle: 'Session title';
+    readonly renameUnavailable: 'Could not rename this conversation. Please try again.';
+    readonly roomActionUnavailable: 'Open Members to manage this room; its shortcut is unavailable.';
+    readonly memberFailed: 'Task failed';
+    readonly currentConversation: 'Current conversation';
+    readonly loadingAgents: 'Checking available agents…';
+    readonly noAgents: 'No local agents are available on this host.';
+    readonly loginAgents: 'Sign in to an agent on the computer before inviting it.';
+    readonly queued: 'Queued messages';
+    readonly queueError: 'Could not update the queue. Please try again.';
+    readonly editQueued: 'Edit';
+    readonly removeQueued: 'Remove';
+    readonly sendNow: 'Send now';
+    readonly sendingQueued: 'Waiting for host admission…';
+    readonly members: 'Members';
+    readonly membersHint: 'Open a member conversation, or adjust its role.';
+    readonly inviteMember: 'Invite member';
+    readonly memberSettings: 'Member settings';
+    readonly duplicateMember: 'This member name is already in use.';
+    readonly invalidMember: 'Use a name without spaces or @.';
+    readonly roomError: 'Could not complete this request. Check the connection and try again.';
+    readonly mainMember: 'Main agent';
+    readonly openMemberChat: 'Open conversation';
+    readonly awaitingMember: 'Waiting for a first task';
+    readonly agentProvider: 'Agent';
+    readonly chooseProvider: 'Choose an available agent';
+    readonly needsLogin: 'Sign in on computer';
+    readonly memberName: 'Name';
+    readonly memberRole: 'Role instructions';
+    readonly memberRoleHint: 'What should this member focus on?';
+    readonly inviteHint: 'Invitation adds the member. Send an @message in the room to start a task.';
+    readonly roleChangeHint: 'Role changes apply to subsequent dispatches.';
+    readonly advanced: 'Advanced';
+    readonly inheritWorkspace: 'Inherit room workspace';
+    readonly saving: 'Saving…';
+    readonly save: 'Save';
+    readonly stopMemberConfirm: 'Stop this member’s current task?';
+    readonly removeMemberConfirm: 'Remove this member from the room? Its conversation history is retained.';
+    readonly confirm: 'Confirm';
+    readonly stopMember: 'Stop task';
+    readonly removeMember: 'Remove member';
+    readonly backMembers: 'Back to members';
+    readonly memberUnit: 'members';
+    readonly inputTools: 'Add and configure';
+    readonly closeTools: 'Close input tools';
+    readonly attachments: 'Add attachment';
+    readonly commands: 'Commands';
+    readonly permissions: 'Permissions';
+    readonly welcome: 'What would you like to do?';
+    readonly welcomeHint: 'Continue an idea, or start a new task.';
+    readonly menu: 'Conversations';
+    readonly close: 'Close navigation';
+    readonly returnToConversation: 'Return to full conversation';
+    readonly title: 'Your workspace, with you';
+    readonly settings: 'Mobile settings';
+    readonly back: 'Back';
+    readonly display: 'Display';
+    readonly automatic: 'Follow screen size';
+    readonly mobile: 'Mobile';
+    readonly desktop: 'Desktop';
+    readonly restoreMobile: 'Return to mobile layout';
+    readonly appearance: 'Layout applies only to this browser.';
+    readonly connection: 'Connection';
+    readonly reconnect: 'Reconnect';
+    readonly connected: 'Connected';
+    readonly connecting: 'Connecting…';
+    readonly disconnected: 'Connection interrupted';
+    readonly server: 'Host';
+    readonly privacy: 'Models, tools and files run on your host.';
+    readonly done: 'Done';
+    readonly brand: 'DSH';
+    readonly grouping: 'Conversation view';
+    readonly byTime: 'Time';
+    readonly byWorkspace: 'Workspace';
+    readonly today: 'Today';
+    readonly yesterday: 'Yesterday';
+    readonly earlier: 'Earlier';
+    readonly unassignedWorkspace: 'No workspace';
+    readonly scan: 'Scan to connect';
+    readonly conversation: 'Conversation';
+    readonly options: 'Conversation options';
+    readonly connectionSettings: 'Connection settings';
+    readonly libraryEyebrow: 'YOUR WORKSPACE';
+    readonly libraryTitle: 'Pick up where you left off.';
+    readonly librarySubtitle: 'A thought, a conversation, a little progress.';
+    readonly newSession: 'New conversation';
+    readonly searchTitles: 'Search';
+    readonly searchResults: 'Results';
+    readonly recent: 'Recent conversations';
+    readonly workspaces: 'Workspaces';
+    readonly loadingSessions: 'Loading conversations…';
+    readonly noMatches: 'No matching conversations.';
+    readonly noSessions: 'Your conversations will appear here.';
+    readonly navigationError: 'Could not open this conversation. Please try again.';
+    readonly running: 'Working';
+    readonly completed: 'Completed';
+    readonly libraryFooter: 'A little closer, wherever you are.';
+    readonly workspace: 'Open workspace';
+    readonly hostPath: 'Computer directory';
+    readonly hostPathHelp: 'Enter an existing absolute directory on your computer. This does not select a folder on your phone.';
+    readonly openWorkspace: 'Open';
+    readonly cancel: 'Cancel';
+};
+export declare const zh: Record<keyof typeof en, string>;
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        mobile: keyof typeof en;
+    }
+}
+//# sourceMappingURL=locales.d.ts.map