@deepseek-harness-tui/dsh-tui 0.12.0 → 0.14.0

package/lib/types/channel/elicitation.js

@@ -0,0 +1,360 @@
+import { t } from '../i18n.js';
+const rec = (value) => typeof value === 'object' && value !== null && !Array.isArray(value) ? value : undefined;
+const str = (value) => typeof value === 'string' ? value : undefined;
+const num = (value) => typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+/** The choice list of an enum schema (`enum` + `enumNames`, or `oneOf` /
+ *  `anyOf` const + title). Labels are made unique. */
+function choicesOf(schema) {
+    if (schema === undefined)
+        return undefined;
+    const raw = [];
+    if (Array.isArray(schema.enum)) {
+        const names = Array.isArray(schema.enumNames) ? schema.enumNames : [];
+        schema.enum.forEach((value, index) => {
+            if (typeof value !== 'string')
+                return;
+            raw.push({ label: str(names[index]) ?? value, value });
+        });
+    }
+    else {
+        const list = Array.isArray(schema.oneOf) ? schema.oneOf : Array.isArray(schema.anyOf) ? schema.anyOf : undefined;
+        if (list === undefined)
+            return undefined;
+        for (const item of list) {
+            const value = str(rec(item)?.const);
+            if (value === undefined)
+                continue;
+            raw.push({ label: str(rec(item)?.title) ?? value, value });
+        }
+    }
+    if (raw.length === 0)
+        return undefined;
+    const seen = new Set();
+    return raw.map(choice => {
+        let label = choice.label === '' ? choice.value : choice.label;
+        while (seen.has(label))
+            label = `${label} (${choice.value})`;
+        seen.add(label);
+        return { label, value: choice.value };
+    });
+}
+/** The fields of a requested schema, in declaration order. */
+export function formFields(schema) {
+    const root = rec(schema);
+    const properties = rec(root?.properties);
+    if (properties === undefined)
+        return [];
+    const required = new Set(Array.isArray(root?.required) ? root.required.filter((key) => typeof key === 'string') : []);
+    return Object.entries(properties).map(([key, raw]) => {
+        const field = rec(raw) ?? {};
+        const type = str(field.type);
+        const base = {
+            key,
+            title: str(field.title)?.trim() || key,
+            ...(str(field.description)?.trim() ? { description: str(field.description).trim() } : {}),
+            required: required.has(key),
+            schema: field,
+        };
+        if (type === 'boolean')
+            return { ...base, kind: 'boolean' };
+        if (type === 'array') {
+            const choices = choicesOf(rec(field.items));
+            return choices === undefined ? { ...base, kind: 'json' } : { ...base, kind: 'multi', choices };
+        }
+        if (type === 'number' || type === 'integer')
+            return { ...base, kind: type };
+        const choices = choicesOf(field);
+        if (choices !== undefined)
+            return { ...base, kind: 'choice', choices };
+        return { ...base, kind: type === 'string' || type === undefined ? 'text' : 'json' };
+    });
+}
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/u;
+const DATE = /^(\d{4})-(\d{2})-(\d{2})$/u;
+const DATE_TIME = /^(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})(?:\.\d+)?(?:[Zz]|[+-](\d{2}):(\d{2}))$/u;
+/**
+ * A real calendar day (leap years counted). `Date.parse` cannot judge an
+ * RFC3339 date: it rolls impossible days such as 2024-02-31 over into March
+ * instead of refusing them (and rejects legal leap seconds), so the fields
+ * of the captured groups are checked for real.
+ */
+function calendarDay(year, month, day) {
+    if (month < 1 || month > 12 || day < 1)
+        return false;
+    const leap = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    const length = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+    return day <= length;
+}
+/** Validate one typed value against its field; the value or the reason. */
+export function parseFieldText(field, text) {
+    const schema = field.schema;
+    if (field.kind === 'number' || field.kind === 'integer') {
+        const value = Number(text);
+        if (text.trim() === '' || !Number.isFinite(value))
+            return { error: t('elicit-invalid-number') };
+        if (field.kind === 'integer' && !Number.isInteger(value))
+            return { error: t('elicit-invalid-integer') };
+        const min = num(schema.minimum);
+        const max = num(schema.maximum);
+        if (min !== undefined && value < min)
+            return { error: t('elicit-invalid-min', { min }) };
+        if (max !== undefined && value > max)
+            return { error: t('elicit-invalid-max', { max }) };
+        return { value };
+    }
+    if (field.kind === 'json') {
+        let value;
+        try {
+            value = JSON.parse(text);
+        }
+        catch {
+            return { error: t('elicit-invalid-json') };
+        }
+        const type = str(schema.type);
+        const fits = type === 'array'
+            ? Array.isArray(value) && value.every(item => typeof item === 'string')
+            : type === 'object' ? false : typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean';
+        // An MCP form value is a string, number, boolean or string array.
+        if (!fits)
+            return { error: t('elicit-invalid-json') };
+        return { value: value };
+    }
+    const length = [...text].length;
+    const minLength = num(schema.minLength);
+    const maxLength = num(schema.maxLength);
+    if (minLength !== undefined && length < minLength)
+        return { error: t('elicit-invalid-min-length', { n: minLength }) };
+    if (maxLength !== undefined && length > maxLength)
+        return { error: t('elicit-invalid-max-length', { n: maxLength }) };
+    switch (str(schema.format)) {
+        case 'email':
+            if (!EMAIL.test(text))
+                return { error: t('elicit-invalid-email') };
+            break;
+        case 'uri':
+            try {
+                new URL(text);
+            }
+            catch {
+                return { error: t('elicit-invalid-uri') };
+            }
+            break;
+        case 'date': {
+            const match = DATE.exec(text);
+            if (match === null || !calendarDay(Number(match[1]), Number(match[2]), Number(match[3])))
+                return { error: t('elicit-invalid-date') };
+            break;
+        }
+        case 'date-time': {
+            // Full RFC3339: a real day, a clock within range (second 60 = a leap
+            // second, accepted on syntax — whether the day really had one stays
+            // the server's to check), and an explicit timezone (Z, z or ±HH:MM —
+            // required, never the local-time fallback `Date.parse` implies).
+            const match = DATE_TIME.exec(text);
+            if (match === null
+                || !calendarDay(Number(match[1]), Number(match[2]), Number(match[3]))
+                || Number(match[4]) > 23 || Number(match[5]) > 59 || Number(match[6]) > 60
+                || Number(match[7]) > 23 || Number(match[8]) > 59)
+                return { error: t('elicit-invalid-date-time') };
+            break;
+        }
+        default:
+            break;
+    }
+    const pattern = str(schema.pattern);
+    if (pattern !== undefined) {
+        let matches = true;
+        try {
+            matches = new RegExp(pattern, 'u').test(text);
+        }
+        catch {
+            // A pattern this runtime cannot compile is the server's to check.
+        }
+        if (!matches)
+            return { error: t('elicit-invalid-pattern') };
+    }
+    return { value: text };
+}
+/** A short constraint hint for a free-text field (shown under the question). */
+function constraintHint(field) {
+    const schema = field.schema;
+    switch (field.kind) {
+        case 'number':
+        case 'integer': {
+            const min = num(schema.minimum);
+            const max = num(schema.maximum);
+            const kind = t(field.kind === 'integer' ? 'elicit-kind-integer' : 'elicit-kind-number');
+            if (min !== undefined && max !== undefined)
+                return t('elicit-hint-range', { kind, min, max });
+            if (min !== undefined)
+                return t('elicit-hint-min', { kind, min });
+            if (max !== undefined)
+                return t('elicit-hint-max', { kind, max });
+            return kind;
+        }
+        case 'json':
+            return t('elicit-hint-json');
+        case 'text': {
+            const format = str(schema.format);
+            return format === undefined ? undefined : t('elicit-hint-format', { format });
+        }
+        default:
+            return undefined;
+    }
+}
+/** The current language's form labels. */
+export const formLabels = () => ({ skip: t('elicit-skip'), yes: t('elicit-yes'), no: t('elicit-no') });
+/** A field's question (with the reason it is asked again, if any). */
+export function fieldQuestion(field, header, lead, error, labels = formLabels()) {
+    const skip = labels.skip;
+    const detail = [
+        error === undefined ? undefined : t('elicit-invalid', { reason: error }),
+        lead,
+        field.description,
+        constraintHint(field),
+    ].filter((line) => line !== undefined && line !== '').join('\n');
+    const question = field.required ? field.title : t('elicit-optional', { title: field.title });
+    const optional = field.required ? [] : [{ label: skip, description: t('elicit-skip-desc') }];
+    const defaults = (labels) => labels.length === 0 ? {} : { defaultSelected: labels };
+    const base = { question, header, ...(detail === '' ? {} : { detail }) };
+    switch (field.kind) {
+        case 'choice': {
+            const fallback = str(field.schema.default);
+            return { ...base, options: [...field.choices.map(choice => ({ label: choice.label })), ...optional], hideCustomInput: true, ...defaults(field.choices.filter(choice => choice.value === fallback).map(choice => choice.label)) };
+        }
+        case 'boolean': {
+            const { yes, no } = labels;
+            const fallback = field.schema.default;
+            return { ...base, options: [{ label: yes }, { label: no }, ...optional], hideCustomInput: true, ...defaults(fallback === true ? [yes] : fallback === false ? [no] : []) };
+        }
+        case 'multi': {
+            const fallback = Array.isArray(field.schema.default) ? field.schema.default : [];
+            return { ...base, options: [...field.choices.map(choice => ({ label: choice.label })), ...optional], multiSelect: true, hideCustomInput: true, ...defaults(field.choices.filter(choice => fallback.includes(choice.value)).map(choice => choice.label)) };
+        }
+        default:
+            return { ...base, options: optional };
+    }
+}
+/** One answered field: its value, `skip`, or why it is invalid. */
+export function fieldValue(field, answer, labels = formLabels()) {
+    const selected = answer?.selected ?? [];
+    const custom = answer?.custom?.trim() ?? '';
+    const skip = labels.skip;
+    const skipped = selected.includes(skip);
+    switch (field.kind) {
+        case 'choice': {
+            const choice = field.choices.find(item => item.label === selected[0]);
+            if (choice !== undefined)
+                return { value: choice.value };
+            return skipped && !field.required ? { skip: true } : { error: t('elicit-invalid-choice') };
+        }
+        case 'boolean':
+            if (selected[0] === labels.yes)
+                return { value: true };
+            if (selected[0] === labels.no)
+                return { value: false };
+            return skipped && !field.required ? { skip: true } : { error: t('elicit-invalid-choice') };
+        case 'multi': {
+            const values = field.choices.filter(choice => selected.includes(choice.label)).map(choice => choice.value);
+            if (values.length === 0)
+                return skipped && !field.required ? { skip: true } : { error: t('elicit-invalid-choice') };
+            const min = num(field.schema.minItems);
+            const max = num(field.schema.maxItems);
+            if (min !== undefined && values.length < min)
+                return { error: t('elicit-invalid-min-items', { n: min }) };
+            if (max !== undefined && values.length > max)
+                return { error: t('elicit-invalid-max-items', { n: max }) };
+            return { value: values };
+        }
+        default:
+            if (custom === '')
+                return skipped && !field.required ? { skip: true } : { error: t('elicit-invalid-required') };
+            return parseFieldText(field, custom);
+    }
+}
+/** A short server label for the panel header chip. */
+export function serverHeader(name) {
+    const flat = name.replace(/\s+/gu, ' ').trim();
+    return flat.length <= 24 ? flat : `${flat.slice(0, 23)}…`;
+}
+/**
+ * A form elicitation flow: its first ask, then each answered round decides
+ * accept (typed content), decline, or a re-ask of the invalid fields. The
+ * send / decline choice is asked once, after the first round; a re-ask
+ * keeps the values already accepted and replaces the re-asked ones.
+ */
+export function createElicitationForm(request) {
+    const fields = formFields(request.requestedSchema);
+    const header = serverHeader(request.displayName ?? request.serverName);
+    const lead = [request.title, request.message].filter((line) => line !== undefined && line.trim() !== '').join('\n');
+    const send = t('elicit-send');
+    const decline = t('elicit-decline');
+    const labels = formLabels();
+    const confirm = {
+        question: t('elicit-confirm', { server: request.serverName }),
+        header,
+        ...(fields.length === 0 && lead !== '' ? { detail: lead } : {}),
+        options: [{ label: send, description: t('elicit-send-desc') }, { label: decline, description: t('elicit-decline-desc') }],
+        hideCustomInput: true,
+    };
+    const values = new Map();
+    /** The fields the shown ask covers (all of them, then the invalid ones). */
+    let asked = fields;
+    let sending = false;
+    return {
+        questions: [...fields.map((field, index) => fieldQuestion(field, header, index === 0 ? lead : undefined, undefined, labels)), confirm],
+        answer: answers => {
+            if (!sending) {
+                const choice = answers.answers[asked.length]?.selected[0];
+                if (choice !== send)
+                    return { kind: 'decline' };
+                sending = true;
+            }
+            const invalid = [];
+            asked.forEach((field, index) => {
+                const outcome = fieldValue(field, answers.answers[index], labels);
+                if ('error' in outcome)
+                    invalid.push({ field, error: outcome.error });
+                else if ('skip' in outcome)
+                    values.delete(field.key);
+                else
+                    values.set(field.key, outcome.value);
+            });
+            if (invalid.length > 0) {
+                asked = invalid.map(item => item.field);
+                return { kind: 'reask', questions: invalid.map(item => fieldQuestion(item.field, header, undefined, item.error, labels)) };
+            }
+            return { kind: 'accept', content: Object.fromEntries(values) };
+        },
+    };
+}
+/** The URL-mode question; undefined when the request names no URL. */
+export function createElicitationUrlAsk(request) {
+    const target = request.url;
+    if (target === undefined || target.trim() === '')
+        return undefined;
+    const accept = t('elicit-url-accept');
+    const message = request.message ?? '';
+    return {
+        questions: [{
+                question: message.trim() === '' ? t('elicit-url-question', { server: request.serverName }) : message,
+                header: serverHeader(request.displayName ?? request.serverName),
+                detail: t('elicit-url-detail'),
+                link: target,
+                options: [{ label: accept, description: t('elicit-url-accept-desc') }, { label: t('elicit-decline'), description: t('elicit-decline-desc') }],
+                hideCustomInput: true,
+            }],
+        accepted: answers => answers.answers[0]?.selected[0] === accept,
+    };
+}
+/** The notice texts a backend shows around an elicitation. */
+export const elicitationNotices = {
+    /** URL mode: the server asks the user to open a page. */
+    urlOpen: (server, url) => t('elicit-url-notice', { server, url }),
+    /** URL mode: the server reported the flow done. */
+    urlComplete: (server) => t('elicit-url-complete', { server }),
+    /** URL mode without a URL: declined. */
+    urlMissing: (server) => t('elicit-url-missing', { server }),
+    /** A mode this client cannot render: declined. */
+    unsupported: (server, mode) => t('elicit-unsupported', { server, mode }),
+};

package/lib/types/channel/goal-command.d.ts

@@ -0,0 +1,49 @@
+/**
+ * The backend-neutral `/goal` (N6): its grammar for a session that serves
+ * goals through the typed `goals` capability (DSH keeps its own
+ * `dsh-command-goal` registry row and never reaches this), the status it
+ * prints, and the budget readout every goal surface shares.
+ *
+ * Grammar (the DSH command's control words, plus a token budget):
+ *
+ *   /goal                          the current goal (or usage)
+ *   /goal <objective>              set or replace the objective
+ *   /goal --budget 50k <objective> … under a token budget (50000, 50k, 1.5m)
+ *   /goal edit <objective>         replace the objective (same as set)
+ *   /goal pause | resume | clear   only when the word is the whole input
+ *
+ * Pure: parsing and formatting only; the channel core's `backendGoals`
+ * host performs the capability calls.
+ */
+import type { ChannelGoal } from '../adapter/ports/channel-view.js';
+/** What one `/goal` line asks for. */
+export type GoalCommand = {
+    readonly kind: 'status';
+} | {
+    readonly kind: 'set';
+    readonly objective: string;
+    readonly tokenBudget?: number;
+} | {
+    readonly kind: 'pause';
+} | {
+    readonly kind: 'resume';
+} | {
+    readonly kind: 'clear';
+} | {
+    readonly kind: 'invalid';
+    readonly reason: string;
+};
+/** A token budget as typed (`50000`, `50k`, `1.5m`); undefined when invalid. */
+export declare function parseTokenBudget(text: string): number | undefined;
+/** Parse the text after `/goal`. */
+export declare function parseGoalCommand(rawInput: string): GoalCommand;
+type GoalBudget = NonNullable<ChannelGoal['budget']>;
+/** `Used 12.3k / 50k tokens · 4m` (no cap: `Used 12.3k tokens · 4m`). */
+export declare function formatGoalBudget(budget: GoalBudget): string;
+/** The status-footer chip's compact budget: `12.3k/50k` (no cap: `12.3k`). */
+export declare function formatGoalBudgetCompact(budget: GoalBudget): string;
+/** The `/goal` status lines: the goal, its phase, its budget (or rounds),
+ *  why it is blocked; usage when there is none. */
+export declare function goalStatusLines(goal: ChannelGoal | undefined): string[];
+export {};
+//# sourceMappingURL=goal-command.d.ts.map

package/lib/types/channel/goal-command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goal-command.d.ts","sourceRoot":"","sources":["../../../src/channel/goal-command.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAA;AAInE,sCAAsC;AACtC,MAAM,MAAM,WAAW,GACnB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GACnF;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,GAC3B;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAC1B;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAKzD,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAMjE;AAED,oCAAoC;AACpC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,WAAW,CAkB9D;AAED,KAAK,UAAU,GAAG,WAAW,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAA;AAEpD,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAM3D;AAED,8EAA8E;AAC9E,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAGlE;AASD;mDACmD;AACnD,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,MAAM,EAAE,CAWvE"}

package/lib/types/channel/goal-command.js

@@ -0,0 +1,72 @@
+import { t } from '../i18n.js';
+import { formatDuration, formatTokens } from '../terminal-utils/format.js';
+const BUDGET_FLAG = /^--(?:budget|tokens)(?:=(\S+))?$/u;
+const BUDGET_VALUE = /^(\d+(?:\.\d+)?)([km])?$/iu;
+/** A token budget as typed (`50000`, `50k`, `1.5m`); undefined when invalid. */
+export function parseTokenBudget(text) {
+    const match = BUDGET_VALUE.exec(text.replaceAll('_', '').replaceAll(',', ''));
+    if (match === null)
+        return undefined;
+    const scale = match[2]?.toLowerCase() === 'm' ? 1_000_000 : match[2]?.toLowerCase() === 'k' ? 1000 : 1;
+    const value = Math.round(Number(match[1]) * scale);
+    return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+/** Parse the text after `/goal`. */
+export function parseGoalCommand(rawInput) {
+    const input = rawInput.trim();
+    if (input === '')
+        return { kind: 'status' };
+    if (input === 'pause' || input === 'resume' || input === 'clear')
+        return { kind: input };
+    let rest = input;
+    let tokenBudget;
+    const words = rest.split(/\s+/u);
+    const flag = BUDGET_FLAG.exec(words[0]);
+    if (flag !== null) {
+        const value = flag[1] ?? words[1];
+        tokenBudget = value === undefined ? undefined : parseTokenBudget(value);
+        if (tokenBudget === undefined)
+            return { kind: 'invalid', reason: t('goal-backend-bad-budget', { value: value ?? '' }) };
+        rest = words.slice(flag[1] === undefined ? 2 : 1).join(' ');
+    }
+    if (/^edit(?:\s|$)/u.test(rest))
+        rest = rest.slice(4);
+    const objective = rest.trim();
+    if (objective === '')
+        return { kind: 'invalid', reason: t('goal-backend-missing-objective') };
+    return { kind: 'set', objective, ...(tokenBudget === undefined ? {} : { tokenBudget }) };
+}
+/** `Used 12.3k / 50k tokens · 4m` (no cap: `Used 12.3k tokens · 4m`). */
+export function formatGoalBudget(budget) {
+    const time = formatDuration(Math.max(0, budget.timeUsedSeconds) * 1000, { mostSignificantOnly: true });
+    const used = formatTokens(Math.max(0, budget.tokensUsed));
+    return budget.tokenBudget === null
+        ? t('goal-budget-used-open', { used, time })
+        : t('goal-budget-used', { used, budget: formatTokens(budget.tokenBudget), time });
+}
+/** The status-footer chip's compact budget: `12.3k/50k` (no cap: `12.3k`). */
+export function formatGoalBudgetCompact(budget) {
+    const used = formatTokens(Math.max(0, budget.tokensUsed));
+    return budget.tokenBudget === null ? used : `${used}/${formatTokens(budget.tokenBudget)}`;
+}
+const PHASE_KEYS = {
+    active: 'goal-phase-active',
+    paused: 'goal-phase-paused',
+    blocked: 'goal-phase-blocked',
+    complete: 'goal-phase-complete',
+};
+/** The `/goal` status lines: the goal, its phase, its budget (or rounds),
+ *  why it is blocked; usage when there is none. */
+export function goalStatusLines(goal) {
+    if (goal === undefined)
+        return [t('goal-backend-none'), t('goal-backend-usage')];
+    return [
+        t('goal-backend-objective', { objective: goal.objective }),
+        t('goal-backend-phase', { phase: t(PHASE_KEYS[goal.phase]) }),
+        goal.budget === undefined
+            ? t('goal-backend-rounds', { started: goal.roundsStarted, max: goal.maxGoalRounds })
+            : formatGoalBudget(goal.budget),
+        ...(goal.phase === 'blocked' && goal.blockedReason !== undefined ? [t('goal-backend-blocked', { message: goal.blockedReason.message })] : []),
+        t('goal-backend-usage'),
+    ];
+}

package/lib/types/channel/history-restore.d.ts

@@ -0,0 +1,16 @@
+import type { ChatRow } from '../adapter/ports/channel-view.js';
+import type { AgentEvent } from '../agent/events.js';
+import { type ProjectionState } from './projection.js';
+/** Whether the durable record can restore a row (the fold predicate). */
+export declare function anchoredRow(row: ChatRow): boolean;
+/** Restore folded rows from a durable record; returns the rows restored. */
+export declare function restoreFoldedRows(rows: ChatRow[], record: readonly AgentEvent[]): number;
+/** Paint an older history slice into fresh rows (settled, no live effects). */
+export declare function projectHistorySlice(events: readonly AgentEvent[], thinkingFold: ProjectionState['thinkingFold']): ChatRow[];
+/**
+ * Put older rows ahead of the transcript: restored (never folded again),
+ * not fresh (no reveal animation), ids below every row already there.
+ * Returns the rows prepended.
+ */
+export declare function prependHistoryRows(rows: ChatRow[], older: readonly ChatRow[]): number;
+//# sourceMappingURL=history-restore.d.ts.map

package/lib/types/channel/history-restore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"history-restore.d.ts","sourceRoot":"","sources":["../../../src/channel/history-restore.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAsB,OAAO,EAA+B,MAAM,kCAAkC,CAAA;AAChH,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,oBAAoB,CAAA;AAGlE,OAAO,EAAyC,KAAK,eAAe,EAAE,MAAM,iBAAiB,CAAA;AAE7F,yEAAyE;AACzE,wBAAgB,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAWjD;AAED,4EAA4E;AAC5E,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,UAAU,EAAE,GAAG,MAAM,CAoFxF;AAuCD,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,EAAE,YAAY,EAAE,eAAe,CAAC,cAAc,CAAC,GAAG,OAAO,EAAE,CAsB3H;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,SAAS,OAAO,EAAE,GAAG,MAAM,CAcrF"}