@itookit/dsht 0.1.0

package/dist/cost.d.ts

@@ -0,0 +1,97 @@
+import { type ObjectValue } from './wire.ts';
+interface Rates {
+    input: number;
+    cacheRead: number;
+    cacheWrite: number;
+    output: number;
+}
+/** An explicit validity interval and weekday peak windows in the named time zone. */
+export interface PriceVersion {
+    id: string;
+    provider: string;
+    model: string;
+    from: string;
+    until?: string;
+    currency: 'CNY';
+    source: string;
+    timezone: string;
+    peak: Rates;
+    offPeak: Rates;
+    weekdays: number[];
+    windows: [number, number][];
+}
+/** Published rates verified on 2026-09-10; preceding dates require historical configuration. */
+export declare const DEFAULT_PRICES: PriceVersion[];
+/** Validate user-maintained price versions, rejecting ambiguous overlapping intervals.
+ * @param value - Parsed prices.json array.
+ * @returns Price versions with validated rates and schedules.
+ */
+export declare function pricesFrom(value: unknown): PriceVersion[];
+/** Return the calendar date used by both daily and three-calendar-day summaries.
+ * @param time - Epoch milliseconds.
+ * @returns Beijing calendar date, YYYY-MM-DD.
+ */
+export declare function costDay(time: number): string;
+/** Summary always retains the number of unpriced records alongside the known subtotal. */
+export interface CostTotal {
+    amount: number;
+    unknown: number;
+    records: number;
+}
+/** Select a price by event time, applying half-open local peak windows.
+ * @param prices - Validated versions.
+ * @param provider - Provider identity from the recorded request.
+ * @param model - Recorded model name; official DeepSeek aliases fall back to Pro when containing pro, otherwise Flash.
+ * @param time - Recorded settlement timestamp used as a billing-time estimate.
+ * @returns Matching price version and per-million-token rates, if known.
+ */
+export declare function priceAt(prices: PriceVersion[], provider: string, model: string, time: number): {
+    price: PriceVersion;
+    rates: Rates;
+} | undefined;
+/** Keep only billing-relevant fields; prompts, tool bodies, cookies and keys never enter the ledger.
+ * @param records - One HTTP history page's records.
+ * @returns Minimal durable events for a deterministic usage fold.
+ */
+export declare function costRecords(records: unknown): ObjectValue[];
+/** Per-origin cache of priced request settlements; each scan replaces a session at a fixed cut. */
+export declare class CostLedger {
+    readonly prices: PriceVersion[];
+    readonly directory?: string | undefined;
+    private sessions;
+    private totals;
+    scannedAt?: number;
+    scanning: boolean;
+    error: string;
+    constructor(prices?: PriceVersion[], directory?: string | undefined);
+    /** Load immutable cut files, keeping the newest complete scan for each session. */
+    load(): Promise<void>;
+    /** Replace one session using all billing events through the opening snapshot cut.
+     * @param sessionId - Host session identity.
+     * @param cut - Opening cursor, preventing a stale scan from overwriting a newer scan.
+     * @param events - Minimal events returned by costRecords, across all history pages.
+     */
+    replace(sessionId: string, cut: number, events: ObjectValue[]): Promise<void>;
+    /** Whether this session has a complete cached scan.
+     * @param sessionId - Selected session identity.
+     * @returns True when a complete scan is available.
+     */
+    hasSession(sessionId?: string): boolean;
+    /** Describe unpriced model/usage combinations without exposing conversation content.
+     * @returns Unique reasons across cached sessions.
+     */
+    missing(): string[];
+    /** Summarize cached requests across one session or Beijing calendar days.
+     * @param sessionId - Optional session restriction.
+     * @param days - Today or today plus the preceding two calendar days.
+     * @param now - Clock used for date attribution.
+     * @returns Known subtotal and unpriced count; undated records are unpriced in every date range.
+     */
+    total(sessionId?: string, days?: 1 | 3, now?: number): CostTotal;
+}
+/** Compact estimates retain an asterisk whenever a subtotal contains unpriced records.
+ * @param total - Summary from the ledger.
+ * @returns Yuan amount and incompleteness marker.
+ */
+export declare function costText(total: CostTotal): string;
+export {};

package/dist/cost.js

@@ -0,0 +1,267 @@
+/** Versioned CNY estimates from durable request usage; provider invoices remain authoritative. */
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, readFile, readdir, rename, writeFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { object, array } from "./wire.js";
+const clocks = new Map();
+/** Published rates verified on 2026-09-10; preceding dates require historical configuration. */
+export const DEFAULT_PRICES = ['deepseek-v4-flash', 'deepseek-v4-pro', 'deepseek-v4-flash-vision-exp'].map(model => {
+    const scale = model === 'deepseek-v4-pro' ? 3 : 1;
+    return { id: `deepseek-2026-09-10-${model}`, provider: 'deepseek-official', model,
+        from: '2026-09-10T00:00:00+08:00', currency: 'CNY', source: 'https://api-docs.deepseek.com/zh-cn/quick_start/pricing/', timezone: 'Asia/Shanghai',
+        peak: { input: 3 * scale, cacheRead: 0.1 * scale, cacheWrite: 3 * scale, output: 9 * scale },
+        offPeak: { input: 1.5 * scale, cacheRead: 0.05 * scale, cacheWrite: 1.5 * scale, output: 4.5 * scale },
+        weekdays: [1, 2, 3, 4, 5], windows: [[540, 720], [840, 1080]] };
+});
+/** Validate user-maintained price versions, rejecting ambiguous overlapping intervals.
+ * @param value - Parsed prices.json array.
+ * @returns Price versions with validated rates and schedules.
+ */
+export function pricesFrom(value) {
+    if (!Array.isArray(value))
+        throw new Error('prices.json must contain an array');
+    const ids = new Set();
+    for (const raw of value) {
+        const p = object(raw);
+        for (const key of ['id', 'provider', 'model', 'source', 'timezone', 'from'])
+            if (typeof p[key] !== 'string' || !p[key])
+                throw new Error(`Invalid price ${key}`);
+        if (ids.has(String(p.id)))
+            throw new Error('Duplicate price id');
+        ids.add(String(p.id));
+        const from = Date.parse(String(p.from));
+        const until = p.until === undefined ? Infinity : Date.parse(String(p.until));
+        if (!Number.isFinite(from) || !(until > from) || p.currency !== 'CNY')
+            throw new Error('Invalid price interval or currency');
+        new Intl.DateTimeFormat('en', { timeZone: String(p.timezone) }).format();
+        for (const key of ['peak', 'offPeak'])
+            for (const bucket of ['input', 'cacheRead', 'cacheWrite', 'output']) {
+                const rate = object(p[key])[bucket];
+                if (typeof rate !== 'number' || !Number.isFinite(rate) || rate < 0)
+                    throw new Error('Invalid token rate');
+            }
+        if (!Array.isArray(p.weekdays) || p.weekdays.some(d => typeof d !== 'number' || !Number.isInteger(d) || d < 0 || d > 6)
+            || !Array.isArray(p.windows) || p.windows.some(w => !Array.isArray(w) || w.length !== 2 || w.some(n => typeof n !== 'number' || !Number.isInteger(n)) || Number(w[0]) < 0 || Number(w[1]) > 1440 || Number(w[0]) >= Number(w[1])))
+            throw new Error('Invalid peak schedule');
+    }
+    const prices = value;
+    for (const [index, p] of prices.entries())
+        for (const q of prices.slice(index + 1)) {
+            if (p.provider === q.provider && p.model === q.model && Date.parse(p.from) < (q.until ? Date.parse(q.until) : Infinity)
+                && Date.parse(q.from) < (p.until ? Date.parse(p.until) : Infinity))
+                throw new Error('Overlapping price intervals');
+        }
+    return prices;
+}
+/** Return the calendar date used by both daily and three-calendar-day summaries.
+ * @param time - Epoch milliseconds.
+ * @returns Beijing calendar date, YYYY-MM-DD.
+ */
+export function costDay(time) { return new Date(time + 8 * 3600_000).toISOString().slice(0, 10); }
+/** Select a price by event time, applying half-open local peak windows.
+ * @param prices - Validated versions.
+ * @param provider - Provider identity from the recorded request.
+ * @param model - Recorded model name; official DeepSeek aliases fall back to Pro when containing pro, otherwise Flash.
+ * @param time - Recorded settlement timestamp used as a billing-time estimate.
+ * @returns Matching price version and per-million-token rates, if known.
+ */
+export function priceAt(prices, provider, model, time) {
+    const active = (p) => p.provider === provider && Date.parse(p.from) <= time && (p.until === undefined || time < Date.parse(p.until));
+    const family = model.toLowerCase().includes('pro') ? 'deepseek-v4-pro' : 'deepseek-v4-flash';
+    const price = prices.find(p => active(p) && p.model === model)
+        ?? (provider === 'deepseek-official' ? prices.find(p => active(p) && p.model === family) : undefined);
+    if (!price)
+        return;
+    let clock = clocks.get(price.timezone);
+    if (!clock) {
+        clock = new Intl.DateTimeFormat('en-US', { timeZone: price.timezone, weekday: 'short', hour: '2-digit', minute: '2-digit', hourCycle: 'h23' });
+        clocks.set(price.timezone, clock);
+    }
+    const parts = clock.formatToParts(time);
+    const part = (name) => parts.find(p => p.type === name).value;
+    const day = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'].indexOf(part('weekday'));
+    const minute = Number(part('hour')) * 60 + Number(part('minute'));
+    return { price, rates: price.weekdays.includes(day) && price.windows.some(([a, b]) => minute >= a && minute < b) ? price.peak : price.offPeak };
+}
+/** Keep only billing-relevant fields; prompts, tool bodies, cookies and keys never enter the ledger.
+ * @param records - One HTTP history page's records.
+ * @returns Minimal durable events for a deterministic usage fold.
+ */
+export function costRecords(records) {
+    return array(records).map(raw => object(object(raw).event)).filter(e => ['request/context', 'assistant/message', 'assistant/attempt', 'llm/retry-started', 'session/end-seed'].includes(String(e.type))).map(e => {
+        const d = object(e.data);
+        const m = object(d.message ?? {});
+        const stream = array(d.stream ?? []).map(r => object(object(r).chunk ?? {})).filter(c => c.type === 'usage');
+        return { seq: e.seq ?? null, time: e.time ?? null, type: e.type, data: {
+                inherited: d.inherited ?? false, turn: d.turn ?? null, step: d.step ?? null, provider: d.provider ?? null, model: d.model ?? null,
+                source: m.source ?? null, usage: d.usage ?? stream.at(-1)?.usage ?? null,
+            } };
+    });
+}
+/** Per-origin cache of priced request settlements; each scan replaces a session at a fixed cut. */
+export class CostLedger {
+    prices;
+    directory;
+    sessions = new Map();
+    totals = new Map();
+    scannedAt;
+    scanning = false;
+    error = '';
+    constructor(prices = DEFAULT_PRICES, directory) {
+        this.prices = prices;
+        this.directory = directory;
+    }
+    /** Load immutable cut files, keeping the newest complete scan for each session. */
+    async load() {
+        if (!this.directory)
+            return;
+        this.totals.clear();
+        await mkdir(this.directory, { recursive: true, mode: 0o700 });
+        for (const name of await readdir(this.directory)) {
+            if (!name.endsWith('.json'))
+                continue;
+            let raw;
+            try {
+                raw = await readFile(join(this.directory, name), 'utf8');
+            }
+            catch (error) {
+                if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+                    continue;
+                throw error;
+            }
+            const v = JSON.parse(raw);
+            if (v.version !== 1 || typeof v.sessionId !== 'string' || !Number.isSafeInteger(v.cut) || !Array.isArray(v.charges)
+                || v.charges.some(c => !c || typeof c.key !== 'string' || typeof c.provider !== 'string' || typeof c.model !== 'string'
+                    || (c.amount !== undefined && (typeof c.amount !== 'number' || !Number.isFinite(c.amount) || c.amount < 0))
+                    || (c.time !== undefined && (typeof c.time !== 'number' || !Number.isFinite(c.time) || c.time < 0 || c.time > 8.64e15))
+                    || (c.usage !== undefined && Object.values(c.usage).some(n => typeof n !== 'number' || !Number.isSafeInteger(n) || n < 0))))
+                throw new Error('Invalid cost ledger');
+            for (const c of v.charges)
+                if (c.price)
+                    pricesFrom([c.price]);
+            if ((this.sessions.get(v.sessionId)?.cut ?? -2) <= v.cut)
+                this.sessions.set(v.sessionId, v);
+        }
+    }
+    /** Replace one session using all billing events through the opening snapshot cut.
+     * @param sessionId - Host session identity.
+     * @param cut - Opening cursor, preventing a stale scan from overwriting a newer scan.
+     * @param events - Minimal events returned by costRecords, across all history pages.
+     */
+    async replace(sessionId, cut, events) {
+        if ((this.sessions.get(sessionId)?.cut ?? -2) > cut)
+            return;
+        const old = new Map(this.sessions.get(sessionId)?.charges.map(c => [c.key, c]));
+        const charges = [];
+        const inheritedCut = Math.max(-1, ...events.filter(e => e.type === 'session/end-seed' && object(e.data).inherited === true).map(e => Number(e.seq)));
+        let route = {};
+        let last;
+        for (const e of [...new Map(events.map(e => [Number(e.seq), e])).values()].sort((a, b) => Number(a.seq) - Number(b.seq))) {
+            const d = object(e.data);
+            if (e.type === 'request/context') {
+                route = d;
+                continue;
+            }
+            if (Number(e.seq) <= inheritedCut || e.type === 'session/end-seed')
+                continue;
+            if (e.type === 'llm/retry-started') {
+                if (last?.turn === d.turn && last?.step === d.step)
+                    last = undefined;
+                continue;
+            }
+            const source = object(d.source ?? {});
+            const provider = String(source.provider ?? route.provider ?? '');
+            const model = String(source.model ?? route.model ?? '');
+            const time = typeof e.time === 'number' && Number.isFinite(e.time) && e.time >= 0 && e.time <= 8.64e15 ? e.time : undefined;
+            const u = object(d.usage ?? {});
+            const buckets = [u.inputTokens, u.outputTokens, u.cacheReadTokens ?? 0, u.cacheWriteTokens ?? 0];
+            const valid = buckets.every(n => typeof n === 'number' && Number.isSafeInteger(n) && n >= 0)
+                && (u.totalTokens === undefined || typeof u.totalTokens === 'number' && Number.isSafeInteger(u.totalTokens) && u.totalTokens === buckets.reduce((sum, n) => sum + Number(n), 0));
+            const usage = valid ? { input: Number(buckets[0]), output: Number(buckets[1]), cacheRead: Number(buckets[2]), cacheWrite: Number(buckets[3]) } : undefined;
+            const index = last && d.turn !== null && d.step !== null && last.turn === d.turn && last.step === d.step ? last.index : charges.length;
+            const key = charges[index]?.key ?? String(e.seq);
+            if (!usage && charges[index]?.usage)
+                continue;
+            const previous = old.get(key);
+            if (previous?.amount !== undefined && previous.time === time && previous.provider === provider && previous.model === model
+                && usage && previous.usage && Object.keys(usage).every(k => usage[k] === previous.usage[k])) {
+                charges[index] = previous;
+                last = { turn: d.turn, step: d.step, index };
+                continue;
+            }
+            const selected = time === undefined ? undefined : priceAt(previous?.price && previous.provider === provider && previous.model === model ? [previous.price] : this.prices, provider, model, time);
+            const estimate = usage && selected ? (usage.input * selected.rates.input + usage.output * selected.rates.output + usage.cacheRead * selected.rates.cacheRead + usage.cacheWrite * selected.rates.cacheWrite) / 1e6 : undefined;
+            const amount = estimate !== undefined && Number.isFinite(estimate) ? estimate : undefined;
+            charges[index] = { key, time, provider, model, usage, price: selected?.price, amount,
+                reason: !usage ? 'missing usage' : time === undefined ? 'missing timestamp' : !selected ? 'no price version' : amount === undefined ? 'invalid estimate' : undefined };
+            last = { turn: d.turn, step: d.step, index };
+        }
+        const saved = { version: 1, sessionId, cut, charges };
+        if (this.directory) {
+            const prefix = createHash('sha256').update(sessionId).digest('hex') + '-';
+            const filename = `${prefix}${cut}.json`;
+            const temporary = join(this.directory, `${randomUUID()}.tmp`);
+            try {
+                await writeFile(temporary, JSON.stringify(saved) + '\n', { mode: 0o600, flag: 'wx' });
+                await rename(temporary, join(this.directory, filename));
+            }
+            finally {
+                await unlink(temporary).catch(error => { if (error.code !== 'ENOENT')
+                    throw error; });
+            }
+            for (const name of await readdir(this.directory))
+                if (name.startsWith(prefix) && name.endsWith('.json') && Number(name.slice(prefix.length, -5)) < cut) {
+                    await unlink(join(this.directory, name)).catch(error => { if (error.code !== 'ENOENT')
+                        throw error; });
+                }
+        }
+        this.sessions.set(sessionId, saved);
+        this.totals.clear();
+    }
+    /** Whether this session has a complete cached scan.
+     * @param sessionId - Selected session identity.
+     * @returns True when a complete scan is available.
+     */
+    hasSession(sessionId) { return sessionId !== undefined && this.sessions.has(sessionId); }
+    /** Describe unpriced model/usage combinations without exposing conversation content.
+     * @returns Unique reasons across cached sessions.
+     */
+    missing() {
+        return [...new Set([...this.sessions.values()].flatMap(s => s.charges.filter(c => c.amount === undefined).map(c => `${c.provider}/${c.model}: ${c.reason}`)))];
+    }
+    /** Summarize cached requests across one session or Beijing calendar days.
+     * @param sessionId - Optional session restriction.
+     * @param days - Today or today plus the preceding two calendar days.
+     * @param now - Clock used for date attribution.
+     * @returns Known subtotal and unpriced count; undated records are unpriced in every date range.
+     */
+    total(sessionId, days, now = Date.now()) {
+        const cacheKey = JSON.stringify([sessionId, days, days ? costDay(now) : '']);
+        const cached = this.totals.get(cacheKey);
+        if (cached)
+            return cached;
+        const result = { amount: 0, unknown: 0, records: 0 };
+        const end = costDay(now);
+        const start = costDay(now - ((days ?? 1) - 1) * 86400_000);
+        for (const session of this.sessions.values()) {
+            if (sessionId !== undefined && session.sessionId !== sessionId)
+                continue;
+            for (const charge of session.charges) {
+                if (days && charge.time !== undefined && (costDay(charge.time) < start || costDay(charge.time) > end))
+                    continue;
+                result.records++;
+                if (charge.amount === undefined || days && charge.time === undefined)
+                    result.unknown++;
+                else
+                    result.amount += charge.amount;
+            }
+        }
+        this.totals.set(cacheKey, result);
+        return result;
+    }
+}
+/** Compact estimates retain an asterisk whenever a subtotal contains unpriced records.
+ * @param total - Summary from the ledger.
+ * @returns Yuan amount and incompleteness marker.
+ */
+export function costText(total) { return `~¥${total.amount.toFixed(4)}${total.unknown ? '*' : ''}`; }

package/dist/endpoint.d.ts

@@ -0,0 +1,16 @@
+/** Resolve the host URL and startup token from the command line and environment. */
+/** Bare host URL plus the startup token that applies to it. */
+export interface Endpoint {
+    readonly url: string;
+    readonly token: string | undefined;
+}
+/**
+ * Split an optional `token` query parameter from the host URL.
+ *
+ * `dsh web` prints its URL with that parameter, so the printed line can be exported as
+ * `DSH_URL` unchanged. The token is never written to disk; only the resulting cookie is.
+ * @param url - Host URL, with or without a `token` query parameter.
+ * @param token - `DSH_TOKEN` value, which takes precedence over the URL parameter.
+ * @returns The URL without its `token` parameter and the effective startup token.
+ */
+export declare function endpoint(url: string, token: string | undefined): Endpoint;

package/dist/endpoint.js

@@ -0,0 +1,16 @@
+/** Resolve the host URL and startup token from the command line and environment. */
+/**
+ * Split an optional `token` query parameter from the host URL.
+ *
+ * `dsh web` prints its URL with that parameter, so the printed line can be exported as
+ * `DSH_URL` unchanged. The token is never written to disk; only the resulting cookie is.
+ * @param url - Host URL, with or without a `token` query parameter.
+ * @param token - `DSH_TOKEN` value, which takes precedence over the URL parameter.
+ * @returns The URL without its `token` parameter and the effective startup token.
+ */
+export function endpoint(url, token) {
+    const parsed = new URL(url);
+    const fromUrl = parsed.searchParams.get('token');
+    parsed.searchParams.delete('token');
+    return { url: parsed.href, token: token || fromUrl || undefined };
+}

package/dist/history.d.ts

@@ -0,0 +1,17 @@
+import type { Transcript } from './transcript.ts';
+/** Lay out visible conversation records and retain their first terminal row.
+ * @param transcript - Loaded history and active assistant output.
+ * @param width - Available terminal columns.
+ * @returns Rows, messages for the history picker, and record-to-row offsets.
+ */
+export declare function historyLayout(transcript: Transcript, width: number): {
+    messages: import("./transcript.ts").Message[];
+    lines: string[];
+    offsets: Map<number, number>;
+    first: number | undefined;
+};
+/** Parse an exact visible-record sequence or an endpoint alias.
+ * @param value - Text after /jump.
+ * @returns A non-negative sequence, first, or last.
+ */
+export declare function jumpTarget(value: string): number | 'first' | 'last';

package/dist/history.js

@@ -0,0 +1,32 @@
+/** Width-aware history layout shared by scrolling and explicit message jumps. */
+import wrapAnsi from 'wrap-ansi';
+/** Lay out visible conversation records and retain their first terminal row.
+ * @param transcript - Loaded history and active assistant output.
+ * @param width - Available terminal columns.
+ * @returns Rows, messages for the history picker, and record-to-row offsets.
+ */
+export function historyLayout(transcript, width) {
+    const wrap = (value) => wrapAnsi(value, width, { hard: true }).split('\n');
+    const messages = transcript.messagesForWidth(width);
+    const lines = [];
+    const offsets = new Map();
+    for (const message of messages) {
+        offsets.set(message.seq, lines.length);
+        lines.push(...(message.compact ? [] : [message.role]), ...wrap(message.text), '');
+    }
+    const live = transcript.liveTextForWidth(width);
+    if (live)
+        lines.push(...(transcript.liveToolOnly ? [] : ['Assistant · streaming']), ...wrap(live));
+    return { messages, lines, offsets, first: transcript.beforeSeq };
+}
+/** Parse an exact visible-record sequence or an endpoint alias.
+ * @param value - Text after /jump.
+ * @returns A non-negative sequence, first, or last.
+ */
+export function jumpTarget(value) {
+    if (value === 'first' || value === 'last')
+        return value;
+    if (/^\d+$/.test(value) && Number.isSafeInteger(Number(value)))
+        return Number(value);
+    throw new Error('Use /jump <record sequence|first|last>; /history lists record sequences');
+}

package/dist/input.d.ts

@@ -0,0 +1,23 @@
+import { type Key } from 'ink';
+/** Editor offsets are UTF-16 positions at grapheme boundaries; killed text stays local. */
+export interface EditState {
+    text: string;
+    cursor: number;
+    killed: string;
+}
+/** Apply one Ink-decoded terminal key; application commands remain owned by the parent.
+ * @param state - Current text, cursor, and most recently killed text.
+ * @param input - Decoded text or control-key letter.
+ * @param key - Ink's VT/terminal key flags.
+ * @returns The next editor state, without sending a message or exiting.
+ */
+export declare function editInput(state: EditState, input: string, key: Partial<Key>): EditState;
+/** Controlled composer with local cursor and kill buffer; Enter submission belongs to the caller. */
+export declare function TextInput({ value, onChange, onCursorChange, onSubmit, focus, placeholder }: {
+    value: string;
+    onChange(value: string): void;
+    onCursorChange(cursor: number): void;
+    onSubmit(): void;
+    focus: boolean;
+    placeholder: string;
+}): import("react").JSX.Element;

package/dist/input.js

@@ -0,0 +1,103 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/** Single-line terminal editing with explicit cursor ownership and Unicode grapheme movement. */
+import { useEffect, useRef, useState } from 'react';
+import { isMouseReport } from "./mouse.js";
+import { Text, useInput, useStdin } from 'ink';
+const segments = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+/** Apply one Ink-decoded terminal key; application commands remain owned by the parent.
+ * @param state - Current text, cursor, and most recently killed text.
+ * @param input - Decoded text or control-key letter.
+ * @param key - Ink's VT/terminal key flags.
+ * @returns The next editor state, without sending a message or exiting.
+ */
+export function editInput(state, input, key) {
+    const { text, cursor, killed } = state;
+    if (key.eventType === 'release' || key.return || key.tab || key.escape || key.upArrow || key.downArrow || key.pageUp || key.pageDown)
+        return state;
+    const previous = () => segments.segment(text).containing(cursor - 1)?.index ?? 0;
+    const next = () => {
+        const part = segments.segment(text).containing(cursor);
+        return part ? part.index + part.segment.length : text.length;
+    };
+    const wordStart = () => text.slice(0, cursor).replace(/\s+$/u, '').replace(/\S+$/u, '').length;
+    const wordEnd = () => cursor + (/^\s*\S+/u.exec(text.slice(cursor))?.[0].length ?? text.length - cursor);
+    const move = (position) => position === cursor ? state : ({ ...state, cursor: position });
+    const remove = (start, end, kill = false) => ({
+        text: text.slice(0, start) + text.slice(end), cursor: start,
+        killed: kill && start !== end ? text.slice(start, end) : killed,
+    });
+    if (key.home || key.ctrl && input === 'a')
+        return move(0);
+    if (key.end || key.ctrl && input === 'e')
+        return move(text.length);
+    if (key.meta && input === 'b' || key.ctrl && key.leftArrow)
+        return move(wordStart());
+    if (key.meta && input === 'f' || key.ctrl && key.rightArrow)
+        return move(wordEnd());
+    if (key.leftArrow || key.ctrl && input === 'b')
+        return move(previous());
+    if (key.rightArrow || key.ctrl && input === 'f')
+        return move(next());
+    if (key.ctrl && input === 'k')
+        return remove(cursor, text.length, true);
+    if (key.ctrl && input === 'u')
+        return remove(0, cursor, true);
+    if (key.ctrl && input === 'w' || key.meta && key.backspace)
+        return remove(wordStart(), cursor, true);
+    if (key.meta && input === 'd')
+        return remove(cursor, wordEnd(), true);
+    if (key.backspace || key.ctrl && input === 'h')
+        return remove(previous(), cursor);
+    if (key.delete || key.ctrl && input === 'd')
+        return remove(cursor, next());
+    if (key.ctrl && input === 'y')
+        return { ...state, text: text.slice(0, cursor) + killed + text.slice(cursor), cursor: cursor + killed.length };
+    if (key.ctrl || key.meta || key.super || key.hyper)
+        return state;
+    const inserted = input.replace(/[\r\n\t]+/g, ' ').replace(/[\u0000-\u001f\u007f-\u009f]/g, '');
+    if (!inserted)
+        return state;
+    return { ...state, text: text.slice(0, cursor) + inserted + text.slice(cursor), cursor: cursor + inserted.length };
+}
+/** Controlled composer with local cursor and kill buffer; Enter submission belongs to the caller. */
+export function TextInput({ value, onChange, onCursorChange, onSubmit, focus, placeholder }) {
+    const { internal_eventEmitter } = useStdin();
+    const rawKey = useRef('');
+    useEffect(() => {
+        // Ink 6 merges DEL (backspace) and CSI 3~ (forward delete) into key.delete.
+        // Capture the same decoded input event before useInput discards its raw bytes.
+        const remember = (raw) => { rawKey.current = raw; };
+        internal_eventEmitter.prependListener('input', remember);
+        return () => { internal_eventEmitter.removeListener('input', remember); };
+    }, [internal_eventEmitter]);
+    const current = useRef({ text: value, cursor: value.length, killed: '' });
+    const [, redraw] = useState(0);
+    if (current.current.text !== value)
+        current.current = { ...current.current, text: value, cursor: value.length };
+    useInput((input, key) => {
+        if (key.eventType === 'release' || isMouseReport(rawKey.current))
+            return;
+        if (key.return) {
+            onSubmit();
+            return;
+        }
+        const before = current.current;
+        const backspace = rawKey.current === '\x7f' || rawKey.current === '\x1b\x7f'
+            || /^\x1b\[127(?:;[\d:]+)?u$/.test(rawKey.current);
+        const after = editInput(before, input, key.delete && backspace ? { ...key, delete: false, backspace: true } : key);
+        current.current = after;
+        if (after.text !== before.text)
+            onChange(after.text);
+        if (after.cursor !== before.cursor || after.text !== before.text)
+            onCursorChange(after.cursor);
+        if (after.text === before.text && after.cursor !== before.cursor)
+            redraw(value => value + 1);
+    }, { isActive: focus });
+    const { text, cursor } = current.current;
+    const character = segments.segment(text).containing(cursor)?.segment ?? ' ';
+    if (!text && !focus)
+        return _jsx(Text, { dimColor: true, children: placeholder });
+    if (!text)
+        return _jsxs(Text, { children: [_jsx(Text, { inverse: true, children: placeholder[0] ?? ' ' }), _jsx(Text, { dimColor: true, children: placeholder.slice(1) })] });
+    return _jsxs(Text, { children: [text.slice(0, cursor), _jsx(Text, { inverse: focus, children: character }), text.slice(cursor + character.length)] });
+}

package/dist/mouse.d.ts

@@ -0,0 +1,14 @@
+/** Recognize complete SGR reports so clicks and wheel bytes never become prompt text.
+ * @param raw - One Ink input-parser event.
+ * @returns Whether this is a mouse report, including non-wheel buttons.
+ */
+export declare function isMouseReport(raw: string): boolean;
+/** Decode vertical wheel presses, ignoring releases, motion and horizontal wheels.
+ * @param raw - One complete SGR mouse report.
+ * @returns Positive for older history, negative for newer history, or zero.
+ */
+export declare function wheelDirection(raw: string): number;
+/** Enable cell-based mouse reports for this mount and restore normal terminal behavior on exit.
+ * @param scroll - Current transcript scrolling callback.
+ */
+export declare function useMouseWheel(scroll: (direction: number) => void): void;

package/dist/mouse.js

@@ -0,0 +1,41 @@
+/** SGR mouse reporting, shared by transcript scrolling and input suppression. */
+import { useEffect, useRef } from 'react';
+import { useStdin, useStdout } from 'ink';
+/** Recognize complete SGR reports so clicks and wheel bytes never become prompt text.
+ * @param raw - One Ink input-parser event.
+ * @returns Whether this is a mouse report, including non-wheel buttons.
+ */
+export function isMouseReport(raw) { return /^\x1b\[<\d+;\d+;\d+[Mm]$/.test(raw); }
+/** Decode vertical wheel presses, ignoring releases, motion and horizontal wheels.
+ * @param raw - One complete SGR mouse report.
+ * @returns Positive for older history, negative for newer history, or zero.
+ */
+export function wheelDirection(raw) {
+    const match = /^\x1b\[<(\d+);\d+;\d+M$/.exec(raw);
+    if (!match)
+        return 0;
+    const button = Number(match[1]);
+    const base = button & ~28;
+    return base === 64 ? 1 : base === 65 ? -1 : 0;
+}
+/** Enable cell-based mouse reports for this mount and restore normal terminal behavior on exit.
+ * @param scroll - Current transcript scrolling callback.
+ */
+export function useMouseWheel(scroll) {
+    const { internal_eventEmitter } = useStdin();
+    const { stdout } = useStdout();
+    const callback = useRef(scroll);
+    callback.current = scroll;
+    useEffect(() => {
+        const onInput = (raw) => { const direction = wheelDirection(raw); if (direction)
+            callback.current(direction); };
+        internal_eventEmitter.on('input', onInput);
+        if (stdout.isTTY)
+            stdout.write('\x1b[?1006h\x1b[?1000h');
+        return () => {
+            internal_eventEmitter.removeListener('input', onInput);
+            if (stdout.isTTY)
+                stdout.write('\x1b[?1000l\x1b[?1006l');
+        };
+    }, [internal_eventEmitter, stdout]);
+}

package/dist/navigation.d.ts

@@ -0,0 +1,11 @@
+/** Shared display names and unambiguous slash-command target resolution. */
+import { type ObjectValue } from './wire.ts';
+/** Parse the short navigation commands and their equivalent long aliases. */
+export declare function navigationCommand(value: string): {
+    kind: 'workspace' | 'session';
+    query?: string;
+} | undefined;
+/** Resolve the host's title projection, falling back to the session ID. */
+export declare function sessionLabel(session: ObjectValue): string;
+/** Match an exact ID or name before a unique ID prefix; never choose an ambiguous target. */
+export declare function resolveTarget(items: ObjectValue[], query: string, id: string, names: (item: ObjectValue) => string[]): ObjectValue;