@hanzo/rooms 0.1.3 → 0.1.5

package/dist/RightPane.js

@@ -14,10 +14,12 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 // OUTPUTS AND SOURCES ARE DERIVED FROM THE TURNS, never from a second list kept
 // in step with them. `LLM.md` already states this rule for `Work` and it is the
 // same rule: the conversation is the record, so a fenced block in an answer IS
-// an output and an image in a question IS a source. There is nothing to sync,
-// nothing to invalidate, and no count that can disagree with the transcript —
-// and switching channels costs no request, because the turns are already in
-// hand. A conversation that has produced nothing says so.
+// an output, and an image in a question or a block in it that names a file IS a
+// source. There is nothing to sync, nothing to invalidate, and no count that
+// can disagree with the transcript — and switching channels costs no request,
+// because the turns are already in hand. The one thing listed that is not yet
+// a turn is what is held for the next message (`hold` in `pane.ts`), which a
+// send spends into one. A conversation that has produced nothing says so.
 //
 // THE COLUMN IS STACKED, NOT SPLIT. The reference this follows puts a ~300px
 // summary beside a wide browser, which needs about 900px of column; the frame
@@ -33,7 +35,7 @@ import { ExternalLink, FileCode, Image as ImageMark, Paperclip, PanelRightClose,
 import { Box, DropdownMenu, DropdownMenuContent, DropdownMenuCheckboxItem, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuTrigger, Text, View, XStack, YStack, } from '@hanzo/ui';
 import { Card, Quiet, Row } from './card.js';
 import { useOpen } from './open.js';
-import { address, channel, hold, name as titleOf, openTab, pickTab, pin, shutTab, usePane, } from './pane.js';
+import { address, channel, name as titleOf, openTab, pickTab, pin, shutTab, take, usePane, } from './pane.js';
 import { useProviders, useSkills } from './tools.js';
 import { activate, startDevice } from './connect.js';
 /** How many rows a card shows before it offers the rest. */
@@ -115,7 +117,11 @@ function outputs(said) {
     });
     return out;
 }
-/** What went into this conversation: pictures asked about, and files brought in. */
+/**
+ * What went into this conversation: pictures asked about, files sent fenced
+ * under their names (`compose` in `lib/attach`), and files held for the next
+ * message.
+ */
 function sources(said, held) {
     const out = [];
     said.forEach((m, turn) => {
@@ -124,15 +130,17 @@ function sources(said, held) {
         pictures(m).forEach((href, i) => {
             out.push({ id: `s${turn}.${i}`, name: 'Attached image', kind: 'image', href });
         });
+        let n = 0;
+        for (const [, info, body] of words(m).matchAll(FENCE)) {
+            n += 1;
+            const named = info.trim();
+            if (!suffix(named))
+                continue;
+            out.push({ id: `sf${turn}.${n}`, name: named, kind: 'file', body, mime: MIME[suffix(named)] ?? 'text/plain' });
+        }
     });
     for (const h of held) {
-        out.push({
-            id: h.id,
-            name: h.name,
-            kind: h.type.startsWith('image/') ? 'image' : 'file',
-            href: h.href,
-            mime: h.type,
-        });
+        out.push({ id: h.id, name: h.name, kind: h.kind === 'image' ? 'image' : 'file', href: h.href, mime: h.type });
     }
     return out;
 }
@@ -238,23 +246,6 @@ const Note = ({ children }) => (_jsx(DropdownMenuLabel, { children: _jsx(Text, {
 function Add({ at }) {
     return (_jsxs(DropdownMenu, { placement: "bottom-end", maxHeight: 420, children: [_jsx(DropdownMenuTrigger, { asChild: true, children: _jsx(Box, { render: "button", "aria-label": "Add to this conversation", p: "$1", rounded: "$2", hoverStyle: { bg: '$hover' }, children: _jsx(Plus, { size: 16, "aria-hidden": true }) }) }), _jsxs(DropdownMenuContent, { align: "end", children: [_jsx(DropdownMenuItem, { onClick: () => take(at), children: _jsx(Word, { children: "Attach files" }) }), _jsx(DropdownMenuSeparator, {}), _jsx(Skills, {}), _jsx(DropdownMenuSeparator, {}), _jsx(Services, {})] })] }));
 }
-/**
- * Asks for files and takes what is given.
- *
- * The picker is the browser's, minted and dropped per press rather than kept as
- * a hidden input in the markup: a menu row is not a form control, and an
- * `<input type=file>` parked in the tree is one more thing for a screen reader
- * to walk past.
- */
-function take(at) {
-    if (typeof document === 'undefined')
-        return;
-    const ask = document.createElement('input');
-    ask.type = 'file';
-    ask.multiple = true;
-    ask.onchange = () => hold(at, Array.from(ask.files ?? []));
-    ask.click();
-}
 /**
  * What this org's agents can reach for, as a section of this menu.
  *

package/dist/cast.d.ts

@@ -24,18 +24,17 @@ interface Role {
      */
     ground?: string;
     /**
-     * The voice the platform reads this character's replies in, by
-     * /v1/audio/speech name.
+     * The voice the platform reads this character's replies in: a speech-service
+     * voice id, sent to /v1/audio/speech as it is. The first letter is the accent
+     * (a American, b British), the second the register (f female, m male).
      *
-     * ONE VOICE PER CHARACTER, and never two who would be in the same room. The
-     * service serves eleven and there are fourteen of them, so three must double
-     * up — the question is which three, and the answer is people who work apart:
-     * the five the demo puts in one call are all distinct. `echo` was reading for
-     * three at once, which in a call is one person doing three parts.
+     * ONE VOICE PER CHARACTER, and never two who would be in the same room. A
+     * house part shares the voice of the character whose face it wears, so Hanzo
+     * Coder sounds like Dev; no two characters share one.
      *
      * CAST, NOT COPIED. These are the speech service's own voices, chosen for fit
-     * — a warm animated reader for the physicist, something low and dry for the
-     * founder. None of them is anybody's actual voice and none is trying to be:
+     * — a playful reader for the physicist, something low and measured for the
+     * quant. None of them is anybody's actual voice and none is trying to be:
      * synthesising a real person saying words they never said is a different act
      * from casting a part, and this is the second one.
      */
@@ -88,18 +87,22 @@ export declare function speakers(text: string, names: string[]): {
     who: string | null;
     text: string;
 }[];
+/**
+ * Every American and British voice the speech service reads in, which is the
+ * pool an agent nobody cast is given a voice from. `am_santa` is left out: it
+ * is a character voice, not a reader.
+ */
 export declare const VOICES: string[];
+/** A voice for a name nobody cast: the same name always gets the same one. */
 export declare function fallbackVoice(name: string | undefined): string;
 /** The voice to read a character's replies in. Always returns a valid voice. */
 export declare const voiceOf: (name: string | undefined) => string;
+/** Who a voice sounds like, read off its id — what a browser voice standing in is matched on. */
 export interface VoiceProfile {
     voice: string;
-    pitch: number;
-    rate: number;
-    description: string;
-    gender: 'male' | 'female' | 'neutral';
+    gender: 'male' | 'female';
+    accent: 'american' | 'british';
 }
-export declare const VOICE_PROFILES: Record<string, VoiceProfile>;
 export declare function voiceProfileOf(name: string | undefined): VoiceProfile;
 export declare function fallbackMemoji(name: string | undefined): string;
 /**

package/dist/cast.js

@@ -24,30 +24,30 @@ export const CAST = {
     //
     // Dev wears its own memoji (black ground baked in, so it fills the disc and
     // needs no rim colour); hanzo coder is that same face under the house name.
-    dev: { portrait: '/agents/dev.png', voice: 'ash' },
-    des: { portrait: '/agents/des.png', ground: '#74569F', voice: 'echo' },
-    vi: { portrait: '/agents/vi.png', ground: '#41649F', voice: 'sage' },
-    antje: { portrait: '/agents/antje.jpg', voice: 'nova' },
-    zach: { portrait: '/agents/zach.jpg', voice: 'onyx' },
-    feynman: { portrait: '/agents/feynman.png', ground: '#9C7C4F', voice: 'fable' },
-    einstein: { portrait: '/agents/einstein.png', ground: '#7D6450', voice: 'verse' },
-    nora: { portrait: '/agents/nora.png', voice: 'shimmer' },
-    creative: { portrait: '/agents/creative.png', voice: 'ballad' },
-    maya: { portrait: '/agents/maya.png', voice: 'coral' },
-    leo: { portrait: '/agents/leo.png', voice: 'alloy' },
+    dev: { portrait: '/agents/dev.png', voice: 'am_michael' },
+    des: { portrait: '/agents/des.png', ground: '#74569F', voice: 'af_bella' },
+    vi: { portrait: '/agents/vi.png', ground: '#41649F', voice: 'am_fenrir' },
+    antje: { portrait: '/agents/antje.jpg', voice: 'af_nova' },
+    zach: { portrait: '/agents/zach.jpg', voice: 'am_onyx' },
+    feynman: { portrait: '/agents/feynman.png', ground: '#9C7C4F', voice: 'am_puck' },
+    einstein: { portrait: '/agents/einstein.png', ground: '#7D6450', voice: 'bm_george' },
+    nora: { portrait: '/agents/nora.png', voice: 'af_heart' },
+    creative: { portrait: '/agents/creative.png', voice: 'bm_fable' },
+    maya: { portrait: '/agents/maya.png', voice: 'bf_emma' },
+    leo: { portrait: '/agents/leo.png', voice: 'am_liam' },
     // THE HOUSE AGENTS, UNDER THE NAMES A READER SEES. Every entry above is keyed
     // by the character; these are keyed by the part.
-    'hanzo coder': { portrait: '/agents/dev.png', voice: 'ash' },
-    'hanzo researcher': { portrait: '/agents/feynman.png', voice: 'fable' },
-    'hanzo designer': { portrait: '/agents/des.png', voice: 'echo' },
-    'hanzo devops': { voice: 'sage' },
-    'hanzo quant': { voice: 'onyx' },
-    'hanzo copywriter': { portrait: '/agents/creative.png', voice: 'ballad' },
-    'hanzo legal & compliance': { portrait: '/agents/einstein.png', voice: 'verse' },
-    'hanzo executive assistant': { portrait: '/agents/maya.png', voice: 'coral' },
-    'hanzo architect': { voice: 'verse' },
-    'hanzo vision': { voice: 'ballad' },
-    'hanzo support': { portrait: '/agents/nora.png', voice: 'shimmer' },
+    'hanzo coder': { portrait: '/agents/dev.png', voice: 'am_michael' },
+    'hanzo researcher': { portrait: '/agents/feynman.png', voice: 'am_puck' },
+    'hanzo designer': { portrait: '/agents/des.png', voice: 'af_bella' },
+    'hanzo devops': { voice: 'am_fenrir' },
+    'hanzo quant': { voice: 'am_onyx' },
+    'hanzo copywriter': { portrait: '/agents/creative.png', voice: 'bm_fable' },
+    'hanzo legal & compliance': { portrait: '/agents/einstein.png', voice: 'bm_george' },
+    'hanzo executive assistant': { portrait: '/agents/maya.png', voice: 'bf_emma' },
+    'hanzo architect': { voice: 'bm_george' },
+    'hanzo vision': { voice: 'bm_fable' },
+    'hanzo support': { portrait: '/agents/nora.png', voice: 'af_heart' },
 };
 /** The role for an agent name, or undefined for one nobody cast. */
 export const roleOf = (name) => CAST[name?.toLowerCase() ?? ''];
@@ -132,22 +132,21 @@ export function speakers(text, names) {
     }
     return out.map((one) => ({ ...one, text: one.text.trim() })).filter((one) => one.text || one.who);
 }
+/**
+ * Every American and British voice the speech service reads in, which is the
+ * pool an agent nobody cast is given a voice from. `am_santa` is left out: it
+ * is a character voice, not a reader.
+ */
 export const VOICES = [
-    'ash',
-    'echo',
-    'sage',
-    'nova',
-    'onyx',
-    'fable',
-    'shimmer',
-    'alloy',
-    'verse',
-    'ballad',
-    'coral',
+    'af_alloy', 'af_aoede', 'af_bella', 'af_heart', 'af_jessica', 'af_kore', 'af_nicole', 'af_nova', 'af_river', 'af_sarah', 'af_sky',
+    'am_adam', 'am_echo', 'am_eric', 'am_fenrir', 'am_liam', 'am_michael', 'am_onyx', 'am_puck',
+    'bf_alice', 'bf_emma', 'bf_isabella', 'bf_lily',
+    'bm_daniel', 'bm_fable', 'bm_george', 'bm_lewis',
 ];
+/** A voice for a name nobody cast: the same name always gets the same one. */
 export function fallbackVoice(name) {
     if (!name)
-        return VOICES[0];
+        return 'af_heart';
     let hash = 0;
     for (let i = 0; i < name.length; i++) {
         hash = (hash << 5) - hash + name.charCodeAt(i);
@@ -157,22 +156,13 @@ export function fallbackVoice(name) {
 }
 /** The voice to read a character's replies in. Always returns a valid voice. */
 export const voiceOf = (name) => roleOf(name)?.voice || fallbackVoice(name);
-export const VOICE_PROFILES = {
-    ash: { voice: 'ash', pitch: 1.0, rate: 1.0, description: 'Clear, direct, technical', gender: 'male' },
-    echo: { voice: 'echo', pitch: 1.1, rate: 1.05, description: 'Adaptive, creative, resonant', gender: 'female' },
-    sage: { voice: 'sage', pitch: 0.95, rate: 1.05, description: 'Authoritative, calm, systems-minded', gender: 'male' },
-    nova: { voice: 'nova', pitch: 1.1, rate: 1.0, description: 'Energetic, articulate, engaging', gender: 'female' },
-    onyx: { voice: 'onyx', pitch: 0.85, rate: 1.0, description: 'Deep, measured, quantitative', gender: 'male' },
-    fable: { voice: 'fable', pitch: 1.05, rate: 1.12, description: 'Warm, enthusiastic, pedagogical', gender: 'male' },
-    shimmer: { voice: 'shimmer', pitch: 1.1, rate: 0.98, description: 'Precise, professional, clear', gender: 'female' },
-    alloy: { voice: 'alloy', pitch: 0.95, rate: 1.05, description: 'Visionary, forward-leaning, focused', gender: 'male' },
-    verse: { voice: 'verse', pitch: 0.9, rate: 0.95, description: 'Intentional, iconic, design-first', gender: 'male' },
-    ballad: { voice: 'ballad', pitch: 0.92, rate: 1.0, description: 'Thoughtful, deep, expansive', gender: 'male' },
-    coral: { voice: 'coral', pitch: 1.15, rate: 1.05, description: 'Friendly, supportive, organized', gender: 'female' },
-};
 export function voiceProfileOf(name) {
-    const v = voiceOf(name);
-    return VOICE_PROFILES[v] || VOICE_PROFILES.ash;
+    const voice = voiceOf(name);
+    return {
+        voice,
+        gender: voice[1] === 'm' ? 'male' : 'female',
+        accent: voice[0] === 'b' ? 'british' : 'american',
+    };
 }
 /** Initials, for anyone with no likeness. Two at most: a disc this size holds
  *  two letters and turns three into a smudge. */

package/dist/lib/attach.d.ts

@@ -5,34 +5,39 @@
  * model reads, and nothing else rides that wire, so a file goes one of two
  * ways: an image as a `data:` URI beside the words, a text file as its own
  * words after the message, fenced under its name. Any other kind is refused by
- * name, before anything is sent.
+ * name, before anything is held.
+ *
+ * This module judges and reads a file; `pane.ts` holds what it admits, per
+ * conversation, for the composer's chips and the column's Sources alike.
  */
 import type { MessagePart } from '@hanzo/ui/chat';
-/** A file held for the next message. */
-export interface Held {
-    id: string;
-    name: string;
+/** What a file contributes to a message once admitted. */
+export interface Admitted {
     kind: 'image' | 'text';
     /** A `data:` URI for an image, the words for a text file. */
     data: string;
-    size: number;
 }
+/** A file as it goes with a message. */
+export type Going = Admitted & {
+    name: string;
+};
 export declare const IMAGE_MAX: number;
 export declare const TEXT_MAX: number;
 /** Which way a file goes with a message, or null when it cannot go. */
 export declare function kindOf(file: {
     name: string;
     type: string;
-}): Held['kind'] | null;
-/** A file read and held, or the sentence that says why it cannot go. */
-export declare function hold(file: File): Promise<Held | string>;
+}): Admitted['kind'] | null;
+/** A file read for a message, or the sentence that says why it cannot go. */
+export declare function admit(file: File): Promise<Admitted | string>;
 /**
- * The message as sent: the words, then each text file fenced under its name.
- * With no words and no text file, the images' names, so the turn says what it
- * carries.
+ * The message as sent: the words, then each text file fenced with its name as
+ * the info string — the shape a model writes a file in, and the one the
+ * column's Sources reads back out of the turn. With no words and no text file,
+ * the images' names, so the turn says what it carries.
  */
-export declare function compose(text: string, files: readonly Held[]): string;
+export declare function compose(text: string, files: readonly Going[]): string;
 /** The images of a message, as the URIs @hanzo/ai's `send` takes. */
-export declare const images: (files: readonly Held[]) => string[];
+export declare const images: (files: readonly Going[]) => string[];
 /** A wire turn's parts — text and `image_url` — as the parts `@hanzo/ui/chat` draws. */
 export declare function partsOf(content: readonly unknown[]): MessagePart[];

package/dist/lib/attach.js

@@ -5,7 +5,10 @@
  * model reads, and nothing else rides that wire, so a file goes one of two
  * ways: an image as a `data:` URI beside the words, a text file as its own
  * words after the message, fenced under its name. Any other kind is refused by
- * name, before anything is sent.
+ * name, before anything is held.
+ *
+ * This module judges and reads a file; `pane.ts` holds what it admits, per
+ * conversation, for the composer's chips and the column's Sources alike.
  */
 export const IMAGE_MAX = 8 * 1024 * 1024;
 export const TEXT_MAX = 256 * 1024;
@@ -30,8 +33,8 @@ function read(file, as) {
             reader.readAsText(file);
     });
 }
-/** A file read and held, or the sentence that says why it cannot go. */
-export async function hold(file) {
+/** A file read for a message, or the sentence that says why it cannot go. */
+export async function admit(file) {
     const kind = kindOf(file);
     if (!kind)
         return `${file.name}: only images and text files go with a message.`;
@@ -39,8 +42,7 @@ export async function hold(file) {
     if (file.size > max)
         return `${file.name} is larger than ${kind === 'image' ? '8 MB' : '256 KB'}.`;
     try {
-        const data = await read(file, kind === 'image' ? 'url' : 'text');
-        return { id: crypto.randomUUID(), name: file.name, kind, data, size: file.size };
+        return { kind, data: await read(file, kind === 'image' ? 'url' : 'text') };
     }
     catch {
         return `${file.name} could not be read.`;
@@ -52,16 +54,17 @@ function fence(words) {
     return '`'.repeat(Math.max(3, longest + 1));
 }
 /**
- * The message as sent: the words, then each text file fenced under its name.
- * With no words and no text file, the images' names, so the turn says what it
- * carries.
+ * The message as sent: the words, then each text file fenced with its name as
+ * the info string — the shape a model writes a file in, and the one the
+ * column's Sources reads back out of the turn. With no words and no text file,
+ * the images' names, so the turn says what it carries.
  */
 export function compose(text, files) {
     const blocks = files
         .filter((f) => f.kind === 'text')
         .map((f) => {
         const f3 = fence(f.data);
-        return `${f.name}\n${f3}\n${f.data.replace(/\n$/, '')}\n${f3}`;
+        return `${f3}${f.name}\n${f.data.replace(/\n$/, '')}\n${f3}`;
     });
     const out = [text.trim(), ...blocks].filter(Boolean).join('\n\n');
     return out || files.map((f) => f.name).join(', ');

package/dist/lib/limits.d.ts

@@ -47,6 +47,15 @@ export declare const spendShown: ({ limits, answered }: {
 export declare const left: (s: Span) => number;
 /** Whether a model is a Hanzo SKU — an Enso or Zen id — the only models a consumer surface offers. */
 export declare const sku: (id: string) => boolean;
+/**
+ * Whether a model can answer a chat turn: it names no outputs, or names text
+ * among them. `zen-scribe` (a transcript) and `zen-voice-mini` (audio) are
+ * Zen ids the catalog lists, and neither answers a question.
+ */
+export declare const chats: (model: {
+    id: string;
+    outputs?: unknown;
+}) => boolean;
 /** A reset as a clock reads it in this browser — "17:00" — or '' for none. */
 export declare function clock(iso: string | null | undefined): string;
 /** A period's end as a sentence states it — "Oct 30, 2026" — or '' for none. Periods end on UTC days. */

package/dist/lib/limits.js

@@ -102,6 +102,12 @@ export const spendShown = ({ limits, answered }) => answered && !limits?.plan;
 export const left = (s) => 100 - s.percent;
 /** Whether a model is a Hanzo SKU — an Enso or Zen id — the only models a consumer surface offers. */
 export const sku = (id) => /^(hanzo\/)?(enso|zen)/i.test(id);
+/**
+ * Whether a model can answer a chat turn: it names no outputs, or names text
+ * among them. `zen-scribe` (a transcript) and `zen-voice-mini` (audio) are
+ * Zen ids the catalog lists, and neither answers a question.
+ */
+export const chats = (model) => !Array.isArray(model.outputs) || model.outputs.includes('text');
 /** A reset as a clock reads it in this browser — "17:00" — or '' for none. */
 export function clock(iso) {
     const t = iso ? Date.parse(iso) : NaN;

package/dist/pane.d.ts

@@ -1,3 +1,4 @@
+import { type Admitted } from './lib/attach.js';
 /** One open tab in the pane's browser. */
 export interface Leaf {
     id: string;
@@ -7,13 +8,14 @@ export interface Leaf {
     title: string;
 }
 /**
- * A file the reader put into this conversation from their own disk.
+ * A file the reader put into this conversation from their own disk, read and
+ * waiting to go with the next message.
  *
  * `href` is an object URL and is the reason this is never written down — see
  * the note at the top. Everything else is read off the `File` itself, so a name
  * and a size here are the file system's, never a guess.
  */
-export interface Held {
+export interface Held extends Admitted {
     id: string;
     name: string;
     size: number;
@@ -29,6 +31,8 @@ export interface Pane {
     /** Whether the summary column stands beside the browser. */
     pinned: boolean;
     held: Held[];
+    /** Why the last files offered were refused, in the reader's words, or null. */
+    refused: string | null;
 }
 /**
  * The conversation a pane belongs to.
@@ -83,8 +87,31 @@ export declare function pickTab(key: string, id: string): void;
 export declare function shutTab(key: string, id: string): void;
 /** Shows or hides the summary column beside this conversation's browser. */
 export declare function pin(key: string, on: boolean): void;
-/** Takes files from the reader's disk into this conversation. */
-export declare function hold(key: string, files: File[]): void;
+/**
+ * Takes files from the reader's disk into this conversation.
+ *
+ * Each is judged and read by `admit`; what is refused is said by name in
+ * `refused` and nothing of it is held, so a chip never stands for a file that
+ * cannot go.
+ */
+export declare function hold(key: string, files: readonly File[]): Promise<void>;
+/**
+ * Asks for files and holds what is given.
+ *
+ * The picker is the browser's, minted and dropped per press rather than kept as
+ * a hidden input in the markup: a menu row is not a form control, and an
+ * `<input type=file>` parked in the tree is one more thing for a screen reader
+ * to walk past.
+ */
+export declare function take(key: string): void;
+/**
+ * Hands over everything held to go with a message, and lets go of it.
+ *
+ * The turn carries each file from here — an image as its `data:` URI, a text
+ * file as its words. The object URLs are left standing, so a tab already open
+ * on one keeps showing it.
+ */
+export declare function spend(key: string): Held[];
 /** Lets go of a file, and of the handle the browser minted for it. */
 export declare function drop(key: string, id: string): void;
 /** This conversation's pane, and it alone — a change to another redraws nothing

package/dist/pane.js

@@ -20,10 +20,17 @@
 // with the document that minted it, so a persisted row would come back as a
 // name pointing at nothing. A row that looks like a file and opens nothing is
 // worse than no row, so they are held for the session and no longer.
+//
+// ONE WAY IN FOR A FILE. The composer's paperclip, a drop on the room, a paste
+// into the field and the column's `+` all call `hold`, so a file is judged by
+// one rule (`lib/attach`), shows as a chip over the field and a row under
+// Sources at once, and goes with the next message. Sending spends what is
+// held; from then on the turn itself is the record Sources reads.
 import { useSyncExternalStore } from 'react';
+import { admit } from './lib/attach.js';
 /** A pane nobody has touched. Shared, and never mutated — see `EMPTY` in
  *  `open.ts` for why a fresh object per read is an infinite render. */
-const BARE = { tabs: [], at: null, pinned: true, held: [] };
+const BARE = { tabs: [], at: null, pinned: true, held: [], refused: null };
 const where = (key) => `hanzo.pane.${key}`;
 /**
  * The conversation a pane belongs to.
@@ -90,6 +97,7 @@ function read(key) {
                 at: tabs.some((t) => t.id === kept.at) ? kept.at : (tabs[0]?.id ?? null),
                 pinned: kept.pinned !== false,
                 held: [],
+                refused: null,
             };
         }
     }
@@ -201,18 +209,58 @@ export function shutTab(key, id) {
 export function pin(key, on) {
     edit(key, (was) => (was.pinned === on ? was : { ...was, pinned: on }));
 }
-/** Takes files from the reader's disk into this conversation. */
-export function hold(key, files) {
+/**
+ * Takes files from the reader's disk into this conversation.
+ *
+ * Each is judged and read by `admit`; what is refused is said by name in
+ * `refused` and nothing of it is held, so a chip never stands for a file that
+ * cannot go.
+ */
+export async function hold(key, files) {
     if (!files.length)
         return;
-    const taken = files.map((f) => ({
-        id: mint('h'),
-        name: f.name,
-        size: f.size,
-        type: f.type,
-        href: URL.createObjectURL(f),
-    }));
-    edit(key, (was) => ({ ...was, held: [...was.held, ...taken] }));
+    const judged = await Promise.all(files.map(admit));
+    const taken = [];
+    const refused = [];
+    judged.forEach((one, i) => {
+        const file = files[i];
+        if (typeof one === 'string')
+            refused.push(one);
+        else
+            taken.push({ id: mint('h'), name: file.name, size: file.size, type: file.type, href: URL.createObjectURL(file), ...one });
+    });
+    edit(key, (was) => ({ ...was, held: [...was.held, ...taken], refused: refused.length ? refused.join(' ') : null }));
+}
+/**
+ * Asks for files and holds what is given.
+ *
+ * The picker is the browser's, minted and dropped per press rather than kept as
+ * a hidden input in the markup: a menu row is not a form control, and an
+ * `<input type=file>` parked in the tree is one more thing for a screen reader
+ * to walk past.
+ */
+export function take(key) {
+    if (typeof document === 'undefined')
+        return;
+    const ask = document.createElement('input');
+    ask.type = 'file';
+    ask.multiple = true;
+    ask.onchange = () => void hold(key, Array.from(ask.files ?? []));
+    ask.click();
+}
+/**
+ * Hands over everything held to go with a message, and lets go of it.
+ *
+ * The turn carries each file from here — an image as its `data:` URI, a text
+ * file as its words. The object URLs are left standing, so a tab already open
+ * on one keeps showing it.
+ */
+export function spend(key) {
+    const was = read(key);
+    if (!was.held.length && !was.refused)
+        return [];
+    write(key, { ...was, held: [], refused: null });
+    return was.held;
 }
 /** Lets go of a file, and of the handle the browser minted for it. */
 export function drop(key, id) {

package/dist/speech.d.ts

@@ -1,16 +1,37 @@
 import React from 'react';
+import { type Refusal } from '@hanzo/voice';
+import { type VoiceProfile } from './cast.js';
 /** Strips code blocks, links, headers, and markdown markup for natural audio speech. */
 export declare function cleanForSpeech(raw: string): string;
+/**
+ * The browser voice that reads when the platform refuses: English, the cast
+ * voice's accent where this browser has it, its register where a name says so.
+ * Read per sentence, because the browser loads its voice list asynchronously.
+ */
+export declare function standIn({ gender, accent }: VoiceProfile, voices: {
+    name: string;
+    lang: string;
+}[]): string | undefined;
 export declare function stopAgentSpeech(): void;
 export interface SpeakOptions {
     agent?: string;
+    /** The reader's IAM bearer (`useIamToken`). Without one the platform refuses
+     *  and the browser reads, which is reported through `onRefusal`. */
+    token?: string | null;
+    /** Speaking began. Fires at once: the request for the audio is part of it. */
     onStart?: () => void;
+    /** Speaking stopped, for any reason: played out, stopped, or replaced. */
     onEnd?: () => void;
     onError?: (err: unknown) => void;
+    /** The platform refused, and whether the browser stood in. */
+    onRefusal?: (refusal: Refusal) => void;
 }
 /**
- * Speak text in the assigned voice of an agent.
+ * Speak text in the assigned voice of an agent, through the platform.
  * Returns a cancel function.
+ *
+ * Call it from the click that asks for it: the player is made inside that
+ * gesture, which is what lets Safari play the reply when it arrives.
  */
 export declare function speakAgent(text: string, options?: SpeakOptions): () => void;
 /**
@@ -19,6 +40,7 @@ export declare function speakAgent(text: string, options?: SpeakOptions): () =>
 export declare function useAgentSpeech(defaultAgent?: string): {
     speaking: boolean;
     currentText: string;
+    refusal: Refusal;
     speak: (text: string, agentName?: string) => void;
     stop: () => void;
     toggle: (text: string, agentName?: string) => void;