@bubblebrain-ai/bubble 0.0.63 → 0.0.64

package/dist/tui/input-history.js

@@ -0,0 +1,250 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { getBubbleHome } from "../bubble-home.js";
+const MAX_HISTORY_ENTRIES = 1000;
+export function defaultHistoryFilePath() {
+    return join(getBubbleHome(), "input-history.jsonl");
+}
+function nonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function normalizeScope(scope) {
+    return {
+        sessionFile: nonEmpty(scope?.sessionFile),
+        cwd: nonEmpty(scope?.cwd),
+    };
+}
+function parseLoadOptions(arg) {
+    if (typeof arg === "string")
+        return { filePath: arg };
+    return { filePath: arg?.filePath ?? defaultHistoryFilePath(), scope: arg?.scope, includeLegacy: arg?.includeLegacy };
+}
+function parseAppendOptions(arg) {
+    if (typeof arg === "string")
+        return { filePath: arg };
+    return { filePath: arg?.filePath ?? defaultHistoryFilePath(), scope: arg?.scope, createdAt: arg?.createdAt };
+}
+function base64FromDataUrl(dataUrl) {
+    const marker = ";base64,";
+    const index = dataUrl.indexOf(marker);
+    return index >= 0 ? dataUrl.slice(index + marker.length) : "";
+}
+function normalizeHistoryImage(input) {
+    if (!input || typeof input !== "object")
+        return null;
+    const image = input;
+    const mediaType = typeof image.mediaType === "string" ? image.mediaType : "";
+    const dataUrl = typeof image.dataUrl === "string" ? image.dataUrl : "";
+    const bytes = typeof image.bytes === "number" && Number.isFinite(image.bytes) ? image.bytes : 0;
+    if (!mediaType || !dataUrl || bytes <= 0)
+        return null;
+    const base64 = typeof image.base64 === "string" && image.base64
+        ? image.base64
+        : base64FromDataUrl(dataUrl);
+    if (!base64)
+        return null;
+    return {
+        mediaType,
+        bytes,
+        dataUrl,
+        base64,
+        ...(typeof image.filename === "string" && image.filename ? { filename: image.filename } : {}),
+        ...(typeof image.sourcePath === "string" && image.sourcePath ? { sourcePath: image.sourcePath } : {}),
+    };
+}
+function normalizeHistoryImages(input) {
+    if (!Array.isArray(input))
+        return [];
+    return input.flatMap((image) => {
+        const normalized = normalizeHistoryImage(image);
+        return normalized ? [normalized] : [];
+    });
+}
+function normalizeImageDisplayStart(input) {
+    return typeof input === "number" && Number.isFinite(input) && input > 0
+        ? Math.floor(input)
+        : undefined;
+}
+function toHistoryEntry(input) {
+    if (typeof input === "string") {
+        return input.trim().length > 0 ? { text: input, images: [] } : null;
+    }
+    const text = typeof input.text === "string" ? input.text : "";
+    const images = normalizeHistoryImages(input.images);
+    const imageDisplayStart = normalizeImageDisplayStart(input.imageDisplayStart);
+    if (text.trim().length === 0 && images.length === 0)
+        return null;
+    return {
+        text,
+        images,
+        ...(imageDisplayStart !== undefined ? { imageDisplayStart } : {}),
+    };
+}
+function historyEntrySignature(entry) {
+    const normalized = typeof entry === "string" ? { text: entry, images: [] } : entry;
+    return JSON.stringify({
+        text: normalized.text,
+        images: normalizeHistoryImages(normalized.images).map((image) => ({
+            mediaType: image.mediaType,
+            bytes: image.bytes,
+            dataUrl: image.dataUrl,
+            filename: image.filename ?? "",
+            sourcePath: image.sourcePath ?? "",
+        })),
+    });
+}
+function serializableHistoryImages(images) {
+    return normalizeHistoryImages(images).map((image) => ({
+        mediaType: image.mediaType,
+        bytes: image.bytes,
+        dataUrl: image.dataUrl,
+        ...(image.filename ? { filename: image.filename } : {}),
+        ...(image.sourcePath ? { sourcePath: image.sourcePath } : {}),
+    }));
+}
+function parseHistoryLine(line) {
+    try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed === "string") {
+            return parsed.length > 0 ? { text: parsed, images: [] } : null;
+        }
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const text = typeof parsed.text === "string" ? parsed.text : "";
+        const images = normalizeHistoryImages(parsed.images);
+        const imageDisplayStart = normalizeImageDisplayStart(parsed.imageDisplayStart);
+        if (text.length === 0 && images.length === 0)
+            return null;
+        return {
+            text,
+            images,
+            ...(imageDisplayStart !== undefined ? { imageDisplayStart } : {}),
+            sessionFile: nonEmpty(parsed.sessionFile),
+            cwd: nonEmpty(parsed.cwd),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function historyEntryMatchesScope(entry, scope, includeLegacy) {
+    const normalized = normalizeScope(scope);
+    if (!scope)
+        return true;
+    if (!normalized.sessionFile)
+        return includeLegacy && !entry.sessionFile;
+    if (!entry.sessionFile)
+        return includeLegacy;
+    return entry.sessionFile === normalized.sessionFile;
+}
+// JSONL on disk: new entries are JSON objects with session metadata and optional
+// image data. Older files used JSON strings; unscoped loads still read them,
+// while scoped loads match only sessionFile so old global history cannot leak
+// into a session.
+export function loadHistoryEntriesSync(arg) {
+    const { filePath, scope, includeLegacy = false } = parseLoadOptions(arg);
+    try {
+        if (!existsSync(filePath))
+            return [];
+        const raw = readFileSync(filePath, "utf8");
+        const out = [];
+        for (const line of raw.split("\n")) {
+            if (!line)
+                continue;
+            const parsed = parseHistoryLine(line);
+            if (!parsed)
+                continue;
+            if (historyEntryMatchesScope(parsed, scope, includeLegacy)) {
+                out.push({
+                    text: parsed.text,
+                    images: parsed.images,
+                    ...(parsed.imageDisplayStart !== undefined ? { imageDisplayStart: parsed.imageDisplayStart } : {}),
+                });
+            }
+        }
+        return out.length > MAX_HISTORY_ENTRIES ? out.slice(-MAX_HISTORY_ENTRIES) : out;
+    }
+    catch {
+        return [];
+    }
+}
+export function loadHistorySync(arg) {
+    return loadHistoryEntriesSync(arg).map((entry) => entry.text);
+}
+export function appendHistoryEntry(entry, arg) {
+    const normalizedEntry = toHistoryEntry(entry);
+    if (!normalizedEntry)
+        return;
+    const { filePath, scope, createdAt } = parseAppendOptions(arg);
+    const normalizedScope = normalizeScope(scope);
+    const timestamp = typeof createdAt === "string"
+        ? createdAt
+        : (createdAt ?? new Date()).toISOString();
+    const record = {
+        text: normalizedEntry.text,
+        createdAt: timestamp,
+        ...(normalizedEntry.images.length > 0 ? { images: serializableHistoryImages(normalizedEntry.images) } : {}),
+        ...(normalizedEntry.imageDisplayStart !== undefined ? { imageDisplayStart: normalizedEntry.imageDisplayStart } : {}),
+        ...(normalizedScope.sessionFile ? { sessionFile: normalizedScope.sessionFile } : {}),
+        ...(normalizedScope.cwd ? { cwd: normalizedScope.cwd } : {}),
+    };
+    try {
+        mkdirSync(dirname(filePath), { recursive: true });
+        appendFileSync(filePath, JSON.stringify(record) + "\n", "utf8");
+    }
+    catch {
+        // Persistence is best-effort; never crash the composer over disk IO.
+    }
+}
+// Pure transition for up/down navigation. `index === null` means the user is
+// editing a fresh draft; otherwise it points at history[index]. When stepping
+// from the draft into history we snapshot the current text so down past the
+// newest entry can restore it.
+export function stepHistory(state, direction, currentEntry) {
+    const { history, index, draft } = state;
+    const current = toHistoryEntry(currentEntry) ?? { text: "", images: [] };
+    const currentDraft = typeof currentEntry === "string" ? currentEntry : current;
+    const noChange = { text: current.text, index, draft, changed: false };
+    const resultFromEntry = (entry, nextIndex, nextDraft) => {
+        const normalized = toHistoryEntry(entry) ?? { text: "", images: [] };
+        return {
+            text: normalized.text,
+            ...(normalized.images.length > 0 ? { images: normalized.images } : {}),
+            ...(normalized.imageDisplayStart !== undefined ? { imageDisplayStart: normalized.imageDisplayStart } : {}),
+            index: nextIndex,
+            draft: nextDraft,
+            changed: true,
+        };
+    };
+    if (direction === "up") {
+        if (history.length === 0)
+            return noChange;
+        if (index === null) {
+            const newIdx = history.length - 1;
+            return resultFromEntry(history[newIdx], newIdx, currentDraft);
+        }
+        if (index > 0) {
+            return resultFromEntry(history[index - 1], index - 1, draft);
+        }
+        return noChange;
+    }
+    if (index === null)
+        return noChange;
+    if (index < history.length - 1) {
+        return resultFromEntry(history[index + 1], index + 1, draft);
+    }
+    return resultFromEntry(draft, null, "");
+}
+export function pushHistoryEntry(history, entry) {
+    const normalizedEntry = toHistoryEntry(entry);
+    if (!normalizedEntry)
+        return history;
+    if (history.length > 0 && historyEntrySignature(history[history.length - 1]) === historyEntrySignature(normalizedEntry)) {
+        return history;
+    }
+    if (typeof entry === "string" && history.every((item) => typeof item === "string")) {
+        return [...history, normalizedEntry.text];
+    }
+    return [...history, entry];
+}

package/dist/tui/markdown-style.d.ts

@@ -0,0 +1,5 @@
+import type { MarkdownTheme } from "@bubblebrain-ai/pi-tui";
+import { type Theme } from "./model/theme.js";
+/** Shared assistant Markdown styling for every transcript host. */
+export declare function createAssistantMarkdownTheme(getTheme: () => Theme): MarkdownTheme;
+export declare const ASSISTANT_MARKDOWN_THEME: MarkdownTheme;

package/dist/tui/markdown-style.js

@@ -0,0 +1,23 @@
+import chalk from "chalk";
+import { darkTheme } from "./model/theme.js";
+import { themeDim, themeForeground } from "./model/theme-style.js";
+/** Shared assistant Markdown styling for every transcript host. */
+export function createAssistantMarkdownTheme(getTheme) {
+    return {
+        heading: (text) => chalk.bold(themeForeground(getTheme().accent, text)),
+        link: (text) => chalk.underline(themeForeground(getTheme().accent, text)),
+        linkUrl: (text) => themeDim(getTheme().dim, text),
+        code: (text) => themeForeground(getTheme().inlineCode, text),
+        codeBlock: (text) => themeForeground(getTheme().agent, text),
+        codeBlockBorder: (text) => themeDim(getTheme().border, text),
+        quote: (text) => themeDim(getTheme().dim, text),
+        quoteBorder: (text) => themeDim(getTheme().border, text),
+        hr: (text) => themeDim(getTheme().border, text),
+        listBullet: (text) => themeForeground(getTheme().accent, text),
+        bold: (text) => chalk.bold(text),
+        italic: (text) => chalk.italic(text),
+        strikethrough: (text) => chalk.strikethrough(text),
+        underline: (text) => chalk.underline(text),
+    };
+}
+export const ASSISTANT_MARKDOWN_THEME = createAssistantMarkdownTheme(() => darkTheme);

package/dist/tui/model/composer-buffer.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Cursor offsets and paste starts are UTF-16 string offsets, matching the rest
+ * of the Ink composer and JavaScript's slice semantics.
+ */
+export interface ComposerPasteSpan {
+    /** Stable identity for this paste occurrence. Marker text is not identity. */
+    id: number;
+    /** Inclusive offset of marker in `ComposerBuffer.text`. */
+    start: number;
+    marker: string;
+    content: string;
+}
+export interface ComposerBuffer {
+    text: string;
+    cursor: number;
+    pastes: ComposerPasteSpan[];
+    /** Monotonic within a live draft; removed paste ids are never reused. */
+    nextPasteId: number;
+}
+export type ComposerCursorBias = "left" | "right" | "nearest";
+export type ComposerPasteAffinity = "inside" | "backward" | "forward";
+export interface ComposerPasteInsertion {
+    content: string;
+    /** Primarily useful for tests and alternate labels. Identity still comes from `id`. */
+    marker?: string;
+}
+export declare function createComposerBuffer(text?: string, cursor?: number): ComposerBuffer;
+/** Full replacement: pasted spans and their id sequence belong to the old draft. */
+export declare function resetComposerBuffer(text?: string, cursor?: number): ComposerBuffer;
+/** Deep enough for a non-persisted history draft snapshot. Strings are immutable. */
+export declare function cloneComposerBuffer(buffer: ComposerBuffer): ComposerBuffer;
+export declare function sanitizeComposerBuffer(buffer: ComposerBuffer, cursorBias?: ComposerCursorBias): ComposerBuffer;
+export declare function normalizeComposerCursor(buffer: ComposerBuffer, requested: number, bias?: ComposerCursorBias): number;
+/**
+ * Replace a half-open range. Any non-empty edit touching part of a registered
+ * paste widens to remove that whole paste. A zero-width insertion inside a
+ * paste snaps to the requested boundary without removing it.
+ */
+export declare function replaceComposerRange(buffer: ComposerBuffer, requestedStart: number, requestedEnd: number, insertion?: string, insertionBias?: ComposerCursorBias): ComposerBuffer;
+export declare function insertComposerText(buffer: ComposerBuffer, text: string): ComposerBuffer;
+export declare function insertComposerPaste(buffer: ComposerBuffer, content: string, marker?: string): ComposerBuffer;
+export declare function insertComposerPaste(buffer: ComposerBuffer, paste: ComposerPasteInsertion): ComposerBuffer;
+export declare function deleteComposerBackward(buffer: ComposerBuffer): ComposerBuffer;
+export declare function deleteComposerForward(buffer: ComposerBuffer): ComposerBuffer;
+export declare function moveComposerCursor(buffer: ComposerBuffer, requested: number, bias?: ComposerCursorBias): ComposerBuffer;
+export declare function findActiveComposerPaste(buffer: ComposerBuffer, affinity?: ComposerPasteAffinity, requestedCursor?: number): ComposerPasteSpan | null;
+export declare function hasActiveComposerPastes(buffer: ComposerBuffer): boolean;
+/**
+ * Expand registered spans only. Descending replacement keeps every earlier
+ * UTF-16 offset stable and never scans inserted content, so expansion cannot
+ * recurse through marker-like pasted text.
+ */
+export declare function expandComposerBuffer(buffer: ComposerBuffer): string;
+export declare function getComposerBufferInvariantErrors(buffer: ComposerBuffer): string[];
+export declare function assertComposerBufferInvariant(buffer: ComposerBuffer): void;

package/dist/tui/model/composer-buffer.js

@@ -0,0 +1,317 @@
+import { createPastedContentMarker } from "../../tui/paste-placeholder.js";
+function clampOffset(text, value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(0, Math.min(text.length, Math.trunc(value)));
+}
+function pasteEnd(paste) {
+    return paste.start + paste.marker.length;
+}
+function safeNextPasteId(buffer) {
+    const supplied = Number.isSafeInteger(buffer.nextPasteId) && buffer.nextPasteId > 0
+        ? buffer.nextPasteId
+        : 1;
+    let next = supplied;
+    for (const paste of buffer.pastes) {
+        if (Number.isSafeInteger(paste?.id) && paste.id > 0) {
+            next = Math.max(next, paste.id + 1);
+        }
+    }
+    return next;
+}
+/**
+ * Keep only spans that are independently valid and unambiguous. Invalid,
+ * overlapping, or duplicate-id spans fail closed: their visible marker text
+ * remains ordinary literal text and their hidden content is never used.
+ */
+function sanitizeCore(buffer) {
+    const text = typeof buffer.text === "string" ? buffer.text : "";
+    const rawPastes = Array.isArray(buffer.pastes) ? buffer.pastes : [];
+    const idCounts = new Map();
+    for (const paste of rawPastes) {
+        if (Number.isSafeInteger(paste?.id) && paste.id > 0) {
+            idCounts.set(paste.id, (idCounts.get(paste.id) ?? 0) + 1);
+        }
+    }
+    const candidates = [];
+    for (let sourceIndex = 0; sourceIndex < rawPastes.length; sourceIndex++) {
+        const paste = rawPastes[sourceIndex];
+        if (!paste || !Number.isSafeInteger(paste.id) || paste.id <= 0)
+            continue;
+        if (!Number.isSafeInteger(paste.start) || paste.start < 0)
+            continue;
+        if (typeof paste.marker !== "string" || paste.marker.length === 0)
+            continue;
+        if (typeof paste.content !== "string")
+            continue;
+        const end = paste.start + paste.marker.length;
+        if (!Number.isSafeInteger(end) || end > text.length)
+            continue;
+        if (text.slice(paste.start, end) !== paste.marker)
+            continue;
+        candidates.push({ ...paste, end, sourceIndex });
+    }
+    candidates.sort((a, b) => a.start - b.start || a.end - b.end || a.sourceIndex - b.sourceIndex);
+    const conflicting = new Set();
+    for (let i = 0; i < candidates.length; i++) {
+        const current = candidates[i];
+        if ((idCounts.get(current.id) ?? 0) > 1)
+            conflicting.add(i);
+        for (let j = i - 1; j >= 0; j--) {
+            const previous = candidates[j];
+            if (previous.end > current.start) {
+                conflicting.add(i);
+                conflicting.add(j);
+            }
+        }
+    }
+    const pastes = candidates
+        .filter((_, index) => !conflicting.has(index))
+        .map(({ end: _end, sourceIndex: _sourceIndex, ...paste }) => paste);
+    return {
+        text,
+        cursor: clampOffset(text, buffer.cursor),
+        pastes,
+        nextPasteId: safeNextPasteId({ ...buffer, text, pastes: rawPastes }),
+    };
+}
+function normalizeWithPastes(text, pastes, requested, bias) {
+    const cursor = clampOffset(text, requested);
+    for (const paste of pastes) {
+        const end = pasteEnd(paste);
+        if (paste.start < cursor && cursor < end) {
+            if (bias === "left")
+                return paste.start;
+            if (bias === "right")
+                return end;
+            const leftDistance = cursor - paste.start;
+            const rightDistance = end - cursor;
+            return leftDistance <= rightDistance ? paste.start : end;
+        }
+    }
+    return cursor;
+}
+function normalizedCore(buffer, bias = "nearest") {
+    const core = sanitizeCore(buffer);
+    return {
+        ...core,
+        cursor: normalizeWithPastes(core.text, core.pastes, core.cursor, bias),
+    };
+}
+export function createComposerBuffer(text = "", cursor = text.length) {
+    const safeText = typeof text === "string" ? text : "";
+    return {
+        text: safeText,
+        cursor: clampOffset(safeText, cursor),
+        pastes: [],
+        nextPasteId: 1,
+    };
+}
+/** Full replacement: pasted spans and their id sequence belong to the old draft. */
+export function resetComposerBuffer(text = "", cursor = text.length) {
+    return createComposerBuffer(text, cursor);
+}
+/** Deep enough for a non-persisted history draft snapshot. Strings are immutable. */
+export function cloneComposerBuffer(buffer) {
+    return {
+        text: buffer.text,
+        cursor: buffer.cursor,
+        pastes: buffer.pastes.map((paste) => ({ ...paste })),
+        nextPasteId: buffer.nextPasteId,
+    };
+}
+export function sanitizeComposerBuffer(buffer, cursorBias = "nearest") {
+    return normalizedCore(buffer, cursorBias);
+}
+export function normalizeComposerCursor(buffer, requested, bias = "nearest") {
+    const core = sanitizeCore(buffer);
+    return normalizeWithPastes(core.text, core.pastes, requested, bias);
+}
+/**
+ * Replace a half-open range. Any non-empty edit touching part of a registered
+ * paste widens to remove that whole paste. A zero-width insertion inside a
+ * paste snaps to the requested boundary without removing it.
+ */
+export function replaceComposerRange(buffer, requestedStart, requestedEnd, insertion = "", insertionBias = "nearest") {
+    const core = sanitizeCore(buffer);
+    let start = clampOffset(core.text, requestedStart);
+    let end = clampOffset(core.text, requestedEnd);
+    if (start > end)
+        [start, end] = [end, start];
+    if (start === end) {
+        start = normalizeWithPastes(core.text, core.pastes, start, insertionBias);
+        end = start;
+    }
+    else {
+        for (const paste of core.pastes) {
+            const tokenEnd = pasteEnd(paste);
+            if (paste.start < end && tokenEnd > start) {
+                start = Math.min(start, paste.start);
+                end = Math.max(end, tokenEnd);
+            }
+        }
+    }
+    const nextText = core.text.slice(0, start) + insertion + core.text.slice(end);
+    const delta = insertion.length - (end - start);
+    const nextPastes = [];
+    for (const paste of core.pastes) {
+        const tokenEnd = pasteEnd(paste);
+        if (tokenEnd <= start) {
+            nextPastes.push(paste);
+            continue;
+        }
+        if (paste.start >= end) {
+            nextPastes.push({ ...paste, start: paste.start + delta });
+        }
+        // Anything else intersects the widened replacement and is removed.
+    }
+    return normalizedCore({
+        text: nextText,
+        cursor: start + insertion.length,
+        pastes: nextPastes,
+        nextPasteId: core.nextPasteId,
+    });
+}
+export function insertComposerText(buffer, text) {
+    return replaceComposerRange(buffer, buffer.cursor, buffer.cursor, text, "nearest");
+}
+export function insertComposerPaste(buffer, contentOrPaste, markerOverride) {
+    const core = normalizedCore(buffer);
+    const content = typeof contentOrPaste === "string" ? contentOrPaste : contentOrPaste.content;
+    const suppliedMarker = typeof contentOrPaste === "string" ? markerOverride : contentOrPaste.marker;
+    const id = core.nextPasteId;
+    const marker = suppliedMarker ?? createPastedContentMarker(content, id);
+    // Never hide content behind an unusable marker.
+    if (marker.length === 0)
+        return insertComposerText(core, content);
+    const start = core.cursor;
+    const inserted = replaceComposerRange(core, start, start, marker, "nearest");
+    const paste = { id, start, marker, content };
+    const pastes = [...inserted.pastes, paste].sort((a, b) => a.start - b.start || a.id - b.id);
+    return normalizedCore({
+        ...inserted,
+        pastes,
+        nextPasteId: id + 1,
+        cursor: start + marker.length,
+    });
+}
+export function deleteComposerBackward(buffer) {
+    const core = sanitizeCore(buffer);
+    const cursor = core.cursor;
+    const paste = core.pastes.find((item) => item.start < cursor && cursor <= pasteEnd(item));
+    if (paste) {
+        return replaceComposerRange(core, paste.start, pasteEnd(paste));
+    }
+    if (cursor <= 0)
+        return normalizedCore(core);
+    return replaceComposerRange(core, cursor - 1, cursor);
+}
+export function deleteComposerForward(buffer) {
+    const core = sanitizeCore(buffer);
+    const cursor = core.cursor;
+    const paste = core.pastes.find((item) => item.start <= cursor && cursor < pasteEnd(item));
+    if (paste) {
+        return replaceComposerRange(core, paste.start, pasteEnd(paste));
+    }
+    if (cursor >= core.text.length)
+        return normalizedCore(core);
+    return replaceComposerRange(core, cursor, cursor + 1);
+}
+export function moveComposerCursor(buffer, requested, bias = "nearest") {
+    const core = sanitizeCore(buffer);
+    return {
+        ...core,
+        cursor: normalizeWithPastes(core.text, core.pastes, requested, bias),
+    };
+}
+export function findActiveComposerPaste(buffer, affinity = "inside", requestedCursor = buffer.cursor) {
+    const core = sanitizeCore(buffer);
+    const cursor = clampOffset(core.text, requestedCursor);
+    const paste = core.pastes.find((item) => {
+        const end = pasteEnd(item);
+        if (affinity === "backward")
+            return item.start < cursor && cursor <= end;
+        if (affinity === "forward")
+            return item.start <= cursor && cursor < end;
+        return item.start < cursor && cursor < end;
+    });
+    return paste ? { ...paste } : null;
+}
+export function hasActiveComposerPastes(buffer) {
+    return sanitizeCore(buffer).pastes.length > 0;
+}
+/**
+ * Expand registered spans only. Descending replacement keeps every earlier
+ * UTF-16 offset stable and never scans inserted content, so expansion cannot
+ * recurse through marker-like pasted text.
+ */
+export function expandComposerBuffer(buffer) {
+    const core = sanitizeCore(buffer);
+    let expanded = core.text;
+    const descending = [...core.pastes].sort((a, b) => b.start - a.start || b.id - a.id);
+    for (const paste of descending) {
+        const end = pasteEnd(paste);
+        expanded = expanded.slice(0, paste.start) + paste.content + expanded.slice(end);
+    }
+    return expanded;
+}
+export function getComposerBufferInvariantErrors(buffer) {
+    const errors = [];
+    if (typeof buffer.text !== "string")
+        errors.push("text must be a string");
+    const text = typeof buffer.text === "string" ? buffer.text : "";
+    if (!Number.isSafeInteger(buffer.cursor) || buffer.cursor < 0 || buffer.cursor > text.length) {
+        errors.push("cursor must be an in-bounds integer");
+    }
+    if (!Number.isSafeInteger(buffer.nextPasteId) || buffer.nextPasteId <= 0) {
+        errors.push("nextPasteId must be a positive integer");
+    }
+    if (!Array.isArray(buffer.pastes)) {
+        errors.push("pastes must be an array");
+        return errors;
+    }
+    const ids = new Set();
+    let previousEnd = 0;
+    let maxId = 0;
+    for (let index = 0; index < buffer.pastes.length; index++) {
+        const paste = buffer.pastes[index];
+        if (!Number.isSafeInteger(paste.id) || paste.id <= 0) {
+            errors.push(`paste ${index} id must be a positive integer`);
+        }
+        else {
+            if (ids.has(paste.id))
+                errors.push(`paste id ${paste.id} is duplicated`);
+            ids.add(paste.id);
+            maxId = Math.max(maxId, paste.id);
+        }
+        if (!Number.isSafeInteger(paste.start) || paste.start < 0) {
+            errors.push(`paste ${index} start must be a non-negative integer`);
+            continue;
+        }
+        if (typeof paste.marker !== "string" || paste.marker.length === 0) {
+            errors.push(`paste ${index} marker must be non-empty`);
+            continue;
+        }
+        const end = pasteEnd(paste);
+        if (end > text.length || text.slice(paste.start, end) !== paste.marker) {
+            errors.push(`paste ${index} marker does not match text`);
+        }
+        if (index > 0 && paste.start < previousEnd) {
+            errors.push(`paste ${index} overlaps or is out of order`);
+        }
+        previousEnd = Math.max(previousEnd, end);
+        if (paste.start < buffer.cursor && buffer.cursor < end) {
+            errors.push("cursor must not be inside a paste span");
+        }
+    }
+    if (buffer.nextPasteId <= maxId) {
+        errors.push("nextPasteId must be greater than every paste id");
+    }
+    return errors;
+}
+export function assertComposerBufferInvariant(buffer) {
+    const errors = getComposerBufferInvariantErrors(buffer);
+    if (errors.length > 0) {
+        throw new Error(`Invalid composer buffer: ${errors.join("; ")}`);
+    }
+}

package/dist/tui/model/composer-types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Composer submission payload — the bridge type between the composer UI and
+ * the agent input path. Lives in the renderer-neutral model layer so the
+ * queue state machine can reference it without importing a renderer.
+ */
+import type { ImageAttachment } from "./image-attachment.js";
+export interface SubmitPayload {
+    /** Fully-expanded text sent to the agent. */
+    text: string;
+    /** Text shown in the composer/transcript when it differs from the real text. */
+    displayText?: string;
+    images: ImageAttachment[];
+    /** First UI-only [Image #N] label reserved for this submitted payload. */
+    imageDisplayStart?: number;
+    /** Harness-initiated submission; runs hidden (task wake path). */
+    internal?: "task_wake";
+}

package/dist/tui/model/composer-types.js

@@ -0,0 +1 @@
+export {};