@elizaos/ui 2.0.3-beta.2 → 2.0.3-beta.3

package/utils/download-share.d.ts

@@ -0,0 +1,65 @@
+/**
+ * download-share.ts — transport-capability-aware download + share helper.
+ *
+ * Client-only utility (no server logger here). Designed to work across:
+ *  - pure browser tabs (web Share API / `<a download>` / showSaveFilePicker),
+ *  - desktop shells (same web paths),
+ *  - Capacitor (iOS/Android) shells via the GLOBAL bridge at
+ *    `globalThis.Capacitor.Plugins.*` — never an `import('@capacitor/...')`,
+ *    because that dependency is intentionally NOT installed yet.
+ *
+ * Everything is SSR-safe: all `window` / `navigator` / `globalThis.Capacitor`
+ * access is guarded with `typeof` checks and never assumes the bridge exists.
+ */
+declare global {
+    interface Window {
+        showSaveFilePicker?: (opts: {
+            suggestedName?: string;
+        }) => Promise<{
+            createWritable: () => Promise<{
+                write: (data: Blob) => Promise<void>;
+                close: () => Promise<void>;
+            }>;
+        }>;
+    }
+}
+/** Extension for a mime type, or `bin` for unknown / empty. */
+export declare function extForMime(mime: string): string;
+/**
+ * Derive a filename from a mime type.
+ *
+ * - If `base` already carries the correct extension, it is returned as-is.
+ * - If `base` is given without an extension, the mime-derived extension is
+ *   appended.
+ * - With no `base`, returns `download.<ext>`.
+ */
+export declare function filenameForMime(mime: string, base?: string): string;
+/**
+ * True when the host can share files / urls: the web Share API is present, OR
+ * a Capacitor Share plugin is available on the global bridge.
+ */
+export declare function canShareFiles(): boolean;
+/**
+ * Download an attachment to the device.
+ *
+ * Native (Capacitor): write to the Cache directory and best-effort share/open.
+ * Web/desktop: try `showSaveFilePicker`, else fetch → blob → `<a download>`.
+ *
+ * Never throws for the common case — failures degrade to the web `<a download>`
+ * fallback. The final fallback may surface an error to the caller's catch.
+ */
+export declare function downloadAttachment(url: string, filename: string): Promise<void>;
+/**
+ * Share an attachment via the platform share sheet.
+ *
+ * Native: `Capacitor.Plugins.Share.share({ url, title })`.
+ * Web: `navigator.share({ url, title })` when available.
+ *
+ * Returns `false` (so the caller can fall back to a download) when no share
+ * path exists or the user cancels. User cancellation (AbortError) is swallowed.
+ */
+export declare function shareAttachment(url: string, opts?: {
+    title?: string;
+    filename?: string;
+}): Promise<boolean>;
+//# sourceMappingURL=download-share.d.ts.map

package/utils/download-share.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"download-share.d.ts","sourceRoot":"","sources":["../../../../../src/utils/download-share.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,kBAAkB,CAAC,EAAE,CAAC,IAAI,EAAE;YAAE,aAAa,CAAC,EAAE,MAAM,CAAA;SAAE,KAAK,OAAO,CAAC;YACjE,cAAc,EAAE,MAAM,OAAO,CAAC;gBAC5B,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;gBACrC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;aAC5B,CAAC,CAAC;SACJ,CAAC,CAAC;KACJ;CACF;AAoGD,+DAA+D;AAC/D,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAG/C;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAOnE;AAID;;;GAGG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAQvC;AAgHD;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,IAAI,CAAC,CAkCf;AAED;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,GAC3C,OAAO,CAAC,OAAO,CAAC,CA8BlB"}

package/utils/download-share.js

@@ -0,0 +1,292 @@
+/**
+ * download-share.ts — transport-capability-aware download + share helper.
+ *
+ * Client-only utility (no server logger here). Designed to work across:
+ *  - pure browser tabs (web Share API / `<a download>` / showSaveFilePicker),
+ *  - desktop shells (same web paths),
+ *  - Capacitor (iOS/Android) shells via the GLOBAL bridge at
+ *    `globalThis.Capacitor.Plugins.*` — never an `import('@capacitor/...')`,
+ *    because that dependency is intentionally NOT installed yet.
+ *
+ * Everything is SSR-safe: all `window` / `navigator` / `globalThis.Capacitor`
+ * access is guarded with `typeof` checks and never assumes the bridge exists.
+ */
+/** Read the Capacitor global without ever importing the SDK. SSR-safe. */
+function getCapacitor() {
+    if (typeof globalThis === "undefined")
+        return undefined;
+    const cap = globalThis.Capacitor;
+    if (cap && typeof cap === "object")
+        return cap;
+    return undefined;
+}
+function getCapacitorShare() {
+    const share = getCapacitor()?.Plugins?.Share;
+    return share && typeof share.share === "function" ? share : undefined;
+}
+function getCapacitorFilesystem() {
+    const fs = getCapacitor()?.Plugins?.Filesystem;
+    return fs && typeof fs.writeFile === "function" ? fs : undefined;
+}
+function isNativePlatform() {
+    const cap = getCapacitor();
+    try {
+        return cap?.isNativePlatform?.() === true;
+    }
+    catch {
+        return false;
+    }
+}
+/* ── Filename derivation ──────────────────────────────────────────────── */
+/**
+ * Small mime → extension map for deriving a sensible filename when none is
+ * provided. Intentionally compact; unknown types fall back to `.bin`.
+ */
+const MIME_EXT = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/gif": "gif",
+    "image/webp": "webp",
+    "image/svg+xml": "svg",
+    "image/bmp": "bmp",
+    "image/avif": "avif",
+    "video/mp4": "mp4",
+    "video/webm": "webm",
+    "video/quicktime": "mov",
+    "video/ogg": "ogv",
+    "audio/mpeg": "mp3",
+    "audio/mp3": "mp3",
+    "audio/wav": "wav",
+    "audio/x-wav": "wav",
+    "audio/ogg": "ogg",
+    "audio/flac": "flac",
+    "audio/aac": "aac",
+    "audio/mp4": "m4a",
+    "audio/opus": "opus",
+    "application/pdf": "pdf",
+    "application/json": "json",
+    "application/zip": "zip",
+    "text/plain": "txt",
+    "text/csv": "csv",
+    "text/markdown": "md",
+    "text/html": "html",
+};
+/** Extension for a mime type, or `bin` for unknown / empty. */
+export function extForMime(mime) {
+    const normalized = (mime || "").split(";")[0].trim().toLowerCase();
+    return MIME_EXT[normalized] ?? "bin";
+}
+/**
+ * Derive a filename from a mime type.
+ *
+ * - If `base` already carries the correct extension, it is returned as-is.
+ * - If `base` is given without an extension, the mime-derived extension is
+ *   appended.
+ * - With no `base`, returns `download.<ext>`.
+ */
+export function filenameForMime(mime, base) {
+    const ext = extForMime(mime);
+    const trimmed = base?.trim();
+    if (!trimmed)
+        return `download.${ext}`;
+    // Already has an extension — trust the caller's filename.
+    if (/\.[a-z0-9]{1,8}$/i.test(trimmed))
+        return trimmed;
+    return `${trimmed}.${ext}`;
+}
+/* ── Capability detection ─────────────────────────────────────────────── */
+/**
+ * True when the host can share files / urls: the web Share API is present, OR
+ * a Capacitor Share plugin is available on the global bridge.
+ */
+export function canShareFiles() {
+    if (getCapacitorShare())
+        return true;
+    if (typeof navigator === "undefined")
+        return false;
+    const nav = navigator;
+    return typeof nav.share === "function" || typeof nav.canShare === "function";
+}
+/* ── Internal helpers ─────────────────────────────────────────────────── */
+function isAbortError(err) {
+    return (err instanceof Error &&
+        (err.name === "AbortError" || /abort|cancel/i.test(err.message)));
+}
+/** Web/desktop fallback: object-URL + temporary `<a download>` click. */
+async function downloadViaAnchor(url, filename) {
+    if (typeof document === "undefined") {
+        throw new Error("downloadAttachment: no document available");
+    }
+    let objectUrl = null;
+    let href = url;
+    try {
+        // Same-origin / fetchable assets: pull to a blob so the download attribute
+        // is honored cross-origin and so blob:/data: sources work uniformly.
+        if (typeof fetch === "function" && !url.startsWith("data:")) {
+            const res = await fetch(url);
+            if (res.ok) {
+                const blob = await res.blob();
+                if (typeof URL !== "undefined" && URL.createObjectURL) {
+                    objectUrl = URL.createObjectURL(blob);
+                    href = objectUrl;
+                }
+            }
+        }
+    }
+    catch {
+        // Network/CORS failure — fall back to linking the raw url directly.
+        href = url;
+    }
+    const anchor = document.createElement("a");
+    anchor.href = href;
+    anchor.download = filename;
+    anchor.rel = "noopener";
+    anchor.style.display = "none";
+    document.body.appendChild(anchor);
+    anchor.click();
+    anchor.remove();
+    if (objectUrl && typeof URL !== "undefined" && URL.revokeObjectURL) {
+        // Revoke after the click has been dispatched.
+        URL.revokeObjectURL(objectUrl);
+    }
+}
+/** Encode an ArrayBuffer to base64 without external deps. SSR-safe. */
+function arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    if (typeof btoa === "function")
+        return btoa(binary);
+    // Node/SSR fallback.
+    if (typeof Buffer !== "undefined") {
+        return Buffer.from(bytes).toString("base64");
+    }
+    throw new Error("base64 encoding unavailable");
+}
+/**
+ * Native path: write the bytes into the Capacitor Cache directory via the
+ * global Filesystem plugin, then best-effort Share/open the resulting file.
+ * Returns true on success; false to signal the caller should fall back.
+ */
+async function downloadViaCapacitor(url, filename) {
+    const fs = getCapacitorFilesystem();
+    if (!fs || typeof fetch !== "function")
+        return false;
+    try {
+        const res = await fetch(url);
+        if (!res.ok)
+            return false;
+        const data = arrayBufferToBase64(await res.arrayBuffer());
+        const written = await fs.writeFile({
+            path: filename,
+            data,
+            directory: "CACHE",
+        });
+        // Best-effort: surface the saved file via the Share sheet so the user can
+        // route it to Files / Photos / another app. Failure here is non-fatal —
+        // the file is already written to the cache.
+        const share = getCapacitorShare();
+        const fileUri = written?.uri ??
+            (typeof fs.getUri === "function"
+                ? (await fs.getUri({ path: filename, directory: "CACHE" }))?.uri
+                : undefined);
+        if (share && fileUri) {
+            try {
+                await share.share({ url: fileUri, title: filename, files: [fileUri] });
+            }
+            catch {
+                // user cancelled or share unavailable — file is still saved.
+            }
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/* ── Public API ───────────────────────────────────────────────────────── */
+/**
+ * Download an attachment to the device.
+ *
+ * Native (Capacitor): write to the Cache directory and best-effort share/open.
+ * Web/desktop: try `showSaveFilePicker`, else fetch → blob → `<a download>`.
+ *
+ * Never throws for the common case — failures degrade to the web `<a download>`
+ * fallback. The final fallback may surface an error to the caller's catch.
+ */
+export async function downloadAttachment(url, filename) {
+    // Native path first when we're truly on a native platform with a bridge.
+    if (isNativePlatform() && getCapacitorFilesystem()) {
+        const ok = await downloadViaCapacitor(url, filename);
+        if (ok)
+            return;
+        // fall through to the web path on any native failure.
+    }
+    // File System Access API (Chromium desktop/web) — lets the user choose where.
+    const picker = typeof window !== "undefined" ? window.showSaveFilePicker : undefined;
+    if (typeof picker === "function" &&
+        typeof fetch === "function" &&
+        !url.startsWith("data:")) {
+        try {
+            const res = await fetch(url);
+            if (res.ok) {
+                const blob = await res.blob();
+                const handle = await picker({ suggestedName: filename });
+                const writable = await handle.createWritable();
+                await writable.write(blob);
+                await writable.close();
+                return;
+            }
+        }
+        catch (err) {
+            // User cancelled the picker — do nothing further (don't double-download).
+            if (isAbortError(err))
+                return;
+            // Otherwise fall through to the anchor fallback.
+        }
+    }
+    await downloadViaAnchor(url, filename);
+}
+/**
+ * Share an attachment via the platform share sheet.
+ *
+ * Native: `Capacitor.Plugins.Share.share({ url, title })`.
+ * Web: `navigator.share({ url, title })` when available.
+ *
+ * Returns `false` (so the caller can fall back to a download) when no share
+ * path exists or the user cancels. User cancellation (AbortError) is swallowed.
+ */
+export async function shareAttachment(url, opts) {
+    const title = opts?.title;
+    const capShare = getCapacitorShare();
+    if (capShare) {
+        try {
+            await capShare.share({ url, title });
+            return true;
+        }
+        catch (err) {
+            if (isAbortError(err))
+                return false;
+            // fall through to the web path.
+        }
+    }
+    if (typeof navigator !== "undefined") {
+        const nav = navigator;
+        if (typeof nav.share === "function") {
+            try {
+                await nav.share({ url, title });
+                return true;
+            }
+            catch (err) {
+                if (isAbortError(err))
+                    return false;
+                return false;
+            }
+        }
+    }
+    return false;
+}

package/utils/event-source.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Safely open an `EventSource`.
+ *
+ * The browser `EventSource` constructor only accepts http(s) URLs and throws a
+ * synchronous `SecurityError: The operation is insecure` for any other scheme.
+ * The iOS on-device agent is addressed through the `eliza-local-agent://ipc`
+ * base, whose SSE routes are served over the native IPC bridge rather than a
+ * real socket — so constructing an `EventSource` against it crashes whatever
+ * surface mounted the subscription (e.g. the home model-status hook), which is
+ * how the local-agent chat surface fell over with "The operation is insecure."
+ *
+ * Returning `null` (instead of throwing) lets callers degrade to their
+ * fetch/poll path. `null` is also returned when `EventSource` is unavailable or
+ * the URL is unparseable, so callers only need a single nullish check.
+ */
+export declare function openEventSource(url: string, init?: EventSourceInit): EventSource | null;
+//# sourceMappingURL=event-source.d.ts.map

package/utils/event-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-source.d.ts","sourceRoot":"","sources":["../../../../../src/utils/event-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAC7B,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE,eAAe,GACrB,WAAW,GAAG,IAAI,CAkBpB"}

package/utils/event-source.js

@@ -0,0 +1,36 @@
+/**
+ * Safely open an `EventSource`.
+ *
+ * The browser `EventSource` constructor only accepts http(s) URLs and throws a
+ * synchronous `SecurityError: The operation is insecure` for any other scheme.
+ * The iOS on-device agent is addressed through the `eliza-local-agent://ipc`
+ * base, whose SSE routes are served over the native IPC bridge rather than a
+ * real socket — so constructing an `EventSource` against it crashes whatever
+ * surface mounted the subscription (e.g. the home model-status hook), which is
+ * how the local-agent chat surface fell over with "The operation is insecure."
+ *
+ * Returning `null` (instead of throwing) lets callers degrade to their
+ * fetch/poll path. `null` is also returned when `EventSource` is unavailable or
+ * the URL is unparseable, so callers only need a single nullish check.
+ */
+export function openEventSource(url, init) {
+    if (typeof EventSource === "undefined")
+        return null;
+    const base = typeof window !== "undefined" ? window.location.href : "http://localhost";
+    let parsed;
+    try {
+        parsed = new URL(url, base);
+    }
+    catch {
+        return null;
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        return null;
+    }
+    try {
+        return new EventSource(url, init);
+    }
+    catch {
+        return null;
+    }
+}

package/utils/image-attachment.d.ts

@@ -1,10 +1,64 @@
-import type { ImageAttachment } from "../api/client-types-chat";
+import type { ImageAttachment } from "../api/client-types-chat.js";
 /**
  * Server-side cap (MAX_CHAT_IMAGES) mirrored client-side so the user gets
  * immediate feedback rather than a 400 after upload. Applies to all attachment
  * kinds, not just images.
  */
 export declare const MAX_CHAT_IMAGES = 4;
+/**
+ * Per-file size cap for a chat attachment, in bytes (20 MB). Enforced
+ * client-side so an oversized file is rejected with a clear notice up front
+ * rather than silently sliced or failing with a 413 after upload.
+ */
+export declare const MAX_ATTACHMENT_BYTES: number;
+/**
+ * Combined size cap across all attachments on a single message, in bytes
+ * (60 MB). Even when every individual file is under {@link MAX_ATTACHMENT_BYTES}
+ * the batch as a whole is bounded so a handful of large-but-legal files can't
+ * blow the request body.
+ */
+export declare const MAX_ATTACHMENTS_TOTAL_BYTES: number;
+/** Human-readable MB for a byte cap, used in user-facing notices. */
+export declare function bytesToMb(bytes: number): number;
+/** A file that was rejected during intake, with the reason it was dropped. */
+export interface DroppedFile {
+    name: string;
+    /** Why the file was rejected. */
+    reason: "too-large" | "over-count";
+}
+/** Outcome of partitioning a candidate file list against the size/count caps. */
+export interface PartitionedAttachmentFiles {
+    /** Files that passed every cap and should be read into attachments. */
+    accepted: File[];
+    /** Files rejected because they (or the running total) exceeded a byte cap. */
+    droppedTooLarge: DroppedFile[];
+    /** Files rejected because they exceeded the per-message count cap. */
+    droppedOverCount: DroppedFile[];
+}
+export interface PartitionAttachmentFilesOptions {
+    /** Per-file byte cap. Defaults to {@link MAX_ATTACHMENT_BYTES}. */
+    maxBytes?: number;
+    /** Combined byte cap. Defaults to {@link MAX_ATTACHMENTS_TOTAL_BYTES}. */
+    maxTotalBytes?: number;
+    /** Max number of accepted files. Defaults to {@link MAX_CHAT_IMAGES}. */
+    maxCount?: number;
+    /**
+     * Count of attachments already pending on the composer, so the count cap is
+     * applied against the combined total rather than just this batch.
+     */
+    existingCount?: number;
+}
+/**
+ * Pure size/count gate for attachment intake. Walks the candidate files in
+ * order and partitions them into accepted vs. dropped, recording *why* each
+ * file was dropped (oversized vs. over the per-message count) so the caller can
+ * surface a "kept N, dropped M" notice instead of silently truncating.
+ *
+ * Order of checks per file: per-file byte cap → running-total byte cap →
+ * count cap. A file that trips any byte cap is reported as `too-large`; a file
+ * that only trips the count cap is reported as `over-count`.
+ */
+export declare function partitionAttachmentFiles(files: FileList | File[], options?: PartitionAttachmentFilesOptions): PartitionedAttachmentFiles;
 /** `accept` attribute for the chat upload <input> — images, audio, video, PDFs, text docs. */
 export declare const CHAT_UPLOAD_ACCEPT = "image/*,audio/*,video/*,application/pdf,text/plain,text/csv,text/markdown";
 /** True when a file's MIME type is an attachment kind chat upload accepts. */
@@ -27,9 +81,107 @@ export declare function createImageThumbnail(file: File): Promise<{
  * Read supported files (images, audio, video, PDFs, text docs) into base64
  * {@link ImageAttachment} payloads (the `data:<mime>;base64,` prefix stripped).
  * Image uploads also get a client-generated thumbnail when large enough.
- * Unsupported files are skipped; the promise rejects if any read fails so the
- * caller can surface it rather than silently dropping an attachment. Shared by
- * the chat composer and the continuous chat overlay.
+ * Unsupported files are skipped; oversized files (per-file or in aggregate) are
+ * filtered out via {@link partitionAttachmentFiles} so an over-cap upload can
+ * never silently slip through to the server. The promise rejects if any read
+ * fails so the caller can surface it rather than silently dropping an
+ * attachment. Shared by the chat composer and the continuous chat overlay.
+ *
+ * Note: only the per-file / total *byte* caps are enforced here; the count cap
+ * is left to the caller (it slices the merged pending list), and drop reporting
+ * for a user-facing notice lives in {@link intakeAttachmentFiles}.
  */
 export declare function filesToImageAttachments(files: FileList | File[]): Promise<ImageAttachment[]>;
+/** Result of {@link intakeAttachmentFiles}: the read attachments plus drops. */
+export interface AttachmentIntakeResult {
+    attachments: ImageAttachment[];
+    droppedTooLarge: DroppedFile[];
+    droppedOverCount: DroppedFile[];
+}
+/**
+ * Full intake pipeline for the chat composer: filters unsupported files,
+ * applies the byte and count caps via {@link partitionAttachmentFiles}, reads
+ * the accepted files into {@link ImageAttachment} payloads, and returns the
+ * dropped files (with reasons) alongside — so the caller can surface a
+ * "kept N, dropped M" notice instead of silently truncating. Rejects only if a
+ * read of an accepted file fails.
+ */
+export declare function intakeAttachmentFiles(files: FileList | File[], options?: PartitionAttachmentFilesOptions): Promise<AttachmentIntakeResult>;
+/**
+ * Build the i18n params for a "kept N, dropped M" notice from an intake/
+ * partition result, or `null` when nothing was dropped (no notice needed).
+ * Pure + testable so the composer just renders the returned counts.
+ */
+export declare function summarizeDroppedAttachments(result: {
+    acceptedCount: number;
+    droppedTooLarge: DroppedFile[];
+    droppedOverCount: DroppedFile[];
+}): {
+    kept: number;
+    dropped: number;
+    droppedTooLarge: number;
+    droppedOverCount: number;
+    maxMb: number;
+} | null;
+/**
+ * Character count at/above which a plain-text paste is converted into a
+ * collapsed text attachment chip (Claude-Code / claude.ai style) rather than
+ * flooding the composer textarea. Pastes shorter than this go into the textarea
+ * as normal.
+ */
+export declare const LARGE_PASTE_CHAR_THRESHOLD = 2000;
+/**
+ * True when a pasted plain-text block is large enough to become a text
+ * attachment instead of landing in the textarea. Uses the *trimmed* length so
+ * surrounding whitespace can't push a small paste over the line. A single bare
+ * URL (no internal whitespace) is never converted — pasting a link should keep
+ * working normally even when the URL is very long.
+ */
+export declare function shouldConvertPasteToAttachment(text: string): boolean;
+/**
+ * Convert a large pasted plain-text block into an {@link ImageAttachment} (the
+ * shared chat-attachment shape) so it renders as a collapsed chip and ships to
+ * the server like any other attachment. `data` is the UTF-8-safe base64 of the
+ * text (no data-URL prefix, matching the other attachment producers here),
+ * `mimeType` is `text/markdown`, and there is no thumbnail. Pure + synchronous
+ * so it unit-tests without the DOM.
+ */
+export declare function pastedTextToAttachment(text: string, opts?: {
+    name?: string;
+}): ImageAttachment;
+/**
+ * Classify a composer paste so both chat surfaces handle clipboard pastes
+ * identically. Returns either:
+ *  - `{ kind: "files" }` — the paste carried image/file data; the caller should
+ *    `preventDefault()` and run the files through {@link intakeAttachmentFiles}.
+ *  - `{ kind: "text-attachment", attachment }` — a large plain-text paste that
+ *    should become a collapsed text-attachment chip (`preventDefault()` first).
+ *  - `{ kind: "passthrough" }` — nothing to intercept; let the textarea handle
+ *    the paste normally (small text, or a lone URL).
+ * Pure + DOM-free so it unit-tests without a real ClipboardEvent.
+ */
+export type ComposerPasteIntent = {
+    kind: "files";
+    files: File[];
+} | {
+    kind: "text-attachment";
+    attachment: ImageAttachment;
+} | {
+    kind: "passthrough";
+};
+export declare function classifyComposerPaste(data: {
+    files: File[];
+    text: string;
+}): ComposerPasteIntent;
+/**
+ * Build the translated "kept N, dropped M" notice for the composer from an
+ * intake/partition result, choosing the right i18n key based on whether the
+ * drops were oversized, over-count, or a mix. Returns `null` when nothing was
+ * dropped. Pure (takes the `t` translator) so it's testable without React.
+ */
+export declare function buildDroppedAttachmentNotice(result: {
+    acceptedCount: number;
+    droppedTooLarge: DroppedFile[];
+    droppedOverCount: DroppedFile[];
+}, t: (key: string, options?: Record<string, unknown>) => string): string | null;
 //# sourceMappingURL=image-attachment.d.ts.map

package/utils/image-attachment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image-attachment.d.ts","sourceRoot":"","sources":["../../../../../src/utils/image-attachment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAEhE;;;;GAIG;AACH,eAAO,MAAM,eAAe,IAAI,CAAC;AAEjC,8FAA8F;AAC9F,eAAO,MAAM,kBAAkB,8EAC8C,CAAC;AAE9E,8EAA8E;AAC9E,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAWzD;AAED,2EAA2E;AAC3E,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,MAAM,GACf,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,UAAU,CAM1C;AAuBD;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,IAAI,GACT,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAgCpD;AAED;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,GAAG,IAAI,EAAE,GACvB,OAAO,CAAC,eAAe,EAAE,CAAC,CA4B5B"}
+{"version":3,"file":"image-attachment.d.ts","sourceRoot":"","sources":["../../../../../src/utils/image-attachment.ts"],"names":[],"mappings":"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"}