@hachej/boring-ui-kit 0.4.13 → 0.4.14

package/dist/file-tree.js

@@ -3,12 +3,23 @@ import { randomUUID } from '@hachej/boring-files/platform';
 const message = (error) => error instanceof Error ? error.message : 'Files could not be loaded';
 const empty = { kind: 'ready', entries: [] };
 const parentOf = (path) => path.slice(0, Math.max(0, path.lastIndexOf('/')));
+const nameOf = (path) => path.slice(path.lastIndexOf('/') + 1);
+/** A file path the tree may write: relative segments, none empty, `.` or `..`, no surrounding space. */
+function checkedPath(path) {
+    const segments = path.split('/');
+    if (!path || segments.some(segment => !segment || segment === '.' || segment === '..' || segment.trim() !== segment))
+        throw new TypeError(`${JSON.stringify(path)} is not a file name the tree can use`);
+    return path;
+}
 const sameBytes = (left, right) => left.length === right.length && left.every((byte, index) => byte === right[index]);
 const sameTarget = (left, right) => left.resource.providerId === right.resource.providerId && left.resource.path === right.resource.path
     && left.view.kind === right.view.kind && (left.view.kind !== 'working' || (right.view.kind === 'working' && left.view.viewId === right.view.viewId));
 /** Browsing state belongs to one borrowed binding. Disposal fences late results; it never closes the workspace. */
 export function createFileTreeController({ revisionProvider }) {
-    let state = { lifecycle: 'active', directories: new Map(), expanded: new Set(), query: '', search: empty, uploads: [] };
+    let state = { lifecycle: 'active', directories: new Map(), expanded: new Set(), query: '', search: empty, uploads: [], mutations: [] };
+    // The revision each row last learned (`prepare`): a rename or delete is refused if the file changed since.
+    const revisions = new Map();
+    const preparing = new Map();
     const listeners = new Set();
     const lifetime = new AbortController();
     const loads = new Map();
@@ -103,6 +114,67 @@ export function createFileTreeController({ revisionProvider }) {
         }
         return result;
     }
+    const unavailableResult = (reason) => ({ kind: 'unavailable', reason });
+    async function latest(path, signal) {
+        const read = await revisionProvider.read({ target: revisionProvider.locate(path), revision: { kind: 'latest' } }, signal);
+        if (read.kind === 'available')
+            return read.snapshot.ref.revision;
+        if (read.kind === 'missing')
+            return { kind: 'conflict', current: [], reason: `${path} is no longer there` };
+        return read;
+    }
+    function settle(current, result) {
+        const settled = { ...current, state: { kind: 'settled', result } };
+        update({ ...state, mutations: state.mutations.map(item => item.operationId === current.operationId ? settled : item) });
+        if (state.lifecycle !== 'active')
+            return settled;
+        // Whatever the outcome, the folders involved are read again, so the tree shows what is there now.
+        const folders = new Set([parentOf(current.path), ...(current.to === undefined ? [] : [parentOf(current.to)])]);
+        if (result.kind === 'committed' && current.to !== undefined && parentOf(current.to))
+            update({ ...state, expanded: new Set([...state.expanded, parentOf(current.to)]) });
+        for (const folder of folders)
+            void refresh(folder);
+        if (state.query)
+            void load('', false, true);
+        return settled;
+    }
+    async function mutate(kind, path, to) {
+        active();
+        if (kind === 'rename' ? !revisionProvider.rename : !revisionProvider.delete)
+            throw new Error(`This workspace cannot ${kind} files`);
+        if (state.mutations.some(item => item.path === path && item.state.kind === 'pending'))
+            throw new Error(`${path} is already being changed; wait for it to finish`);
+        const operationId = randomUUID();
+        const current = { operationId, kind, path, ...(to === undefined ? {} : { to }), state: { kind: 'pending' } };
+        update({ ...state, mutations: [...state.mutations.filter(item => item.path !== path), current] });
+        let result;
+        try {
+            await preparing.get(path);
+            const known = revisions.get(path) ?? await latest(path, lifetime.signal);
+            if (typeof known !== 'string')
+                result = known;
+            else {
+                const from = revisionProvider.locate(path);
+                const answer = kind === 'rename' && to !== undefined
+                    ? await revisionProvider.rename({ from, to: revisionProvider.locate(to), expectedRevision: known, operationId }, lifetime.signal)
+                    : await revisionProvider.delete({ path: from, expectedRevision: known, operationId }, lifetime.signal);
+                try {
+                    result = parsePublicationResult(answer);
+                }
+                catch {
+                    result = unknown(operationId, 'The acknowledgement was invalid; read the folder again before retrying');
+                }
+                if (result.kind === 'partial' || (result.kind === 'unknown' && result.operationId !== operationId))
+                    result = unknown(operationId, 'The acknowledgement did not match its operation');
+            }
+        }
+        catch (error) {
+            result = error instanceof PublicationNotDispatchedError && error.operationId === operationId ? unavailableResult(`${nameOf(path)} was not changed: the request was not sent`)
+                : unknown(operationId, `The outcome is unconfirmed; read the folder again before retrying`);
+        }
+        revisions.delete(path);
+        return settle(current, result);
+    }
     const controller = {
         revisionProvider, getSnapshot: () => state,
         subscribe: listener => { if (state.lifecycle === 'disposed')
@@ -210,6 +282,55 @@ export function createFileTreeController({ revisionProvider }) {
             return controller.upload({ path: attempt.current.path, bytes: attempt.bytes, mediaType: change.mediaType,
                 ...(change.kind === 'replace' ? { replace: change.target } : {}) });
         },
+        actions: { rename: typeof revisionProvider.rename === 'function', delete: typeof revisionProvider.delete === 'function' },
+        prepare: (path, signal) => {
+            try {
+                active();
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+            // A rename or delete started meanwhile waits for this read, so it uses the revision the row learned.
+            const reading = (async () => {
+                try {
+                    const known = await latest(path, signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal);
+                    if (typeof known !== 'string') {
+                        revisions.delete(path);
+                        return undefined;
+                    }
+                    revisions.set(path, known);
+                    return known;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            preparing.set(path, reading);
+            void reading.finally(() => { if (preparing.get(path) === reading)
+                preparing.delete(path); });
+            return reading;
+        },
+        rename: async (path, to) => {
+            checkedPath(path);
+            checkedPath(to);
+            if (to === path)
+                throw new TypeError('The new name is the current name');
+            return mutate('rename', path, to);
+        },
+        move: async (path, folder) => {
+            checkedPath(path);
+            if (folder)
+                checkedPath(folder);
+            const to = folder ? `${folder}/${nameOf(path)}` : nameOf(path);
+            if (to === path)
+                throw new TypeError(`${nameOf(path)} is already in that folder`);
+            if (folder === path || folder.startsWith(`${path}/`))
+                throw new TypeError('A file cannot move into itself');
+            return mutate('rename', path, to);
+        },
+        remove: async (path) => mutate('delete', checkedPath(path)),
+        dismiss: operationId => { if (state.mutations.some(item => item.operationId === operationId && item.state.kind === 'settled'))
+            update({ ...state, mutations: state.mutations.filter(item => item.operationId !== operationId) }); },
         history: (path, signal) => { active(); return revisionProvider.history(path, signal ? AbortSignal.any([signal, lifetime.signal]) : lifetime.signal); },
         dispose: () => { if (state.lifecycle === 'disposed')
             return; lifetime.abort(); for (const load of loads.values())

package/dist/voice-capture.d.ts

@@ -31,8 +31,18 @@ export interface VoiceCaptureOptions {
     readonly maxMs?: number;
     /** The page clock (default `performance.now()`). */
     readonly now?: () => number;
+    /** The Web Audio context for WAV recording (default `new AudioContext()` when the page has one); `null` records with MediaRecorder. */
+    readonly audioContext?: (() => AudioContext) | null;
+    /** How long `start()` waits for the first sound before refusing as `busy` (default 5 s). */
+    readonly firstSoundMs?: number;
 }
 export declare const DEFAULT_MAX_VOICE_MS: number;
+/** WAV recordings are 16 kHz mono 16-bit PCM: 32 kB per second. */
+export declare const WAV_RATE = 16000;
+/** `input` (samples at `from` Hz) at `to` Hz, each output sample the mean of the input samples it covers. */
+export declare function downsample(input: Float32Array, from: number, to?: number): Float32Array;
+/** The WAV file (16-bit PCM, mono) of `chunks` of samples at `rate` Hz, end to end, clipped to [-1, 1]. */
+export declare function encodeWav(chunks: readonly Float32Array[], rate?: number): Uint8Array<ArrayBuffer>;
 /** Container types tried in order; the first the browser records wins. */
 export declare const VOICE_MIME_TYPES: readonly ["audio/webm;codecs=opus", "audio/webm", "audio/mp4", "audio/ogg;codecs=opus"];
 /** The browser's microphone, or null where the page cannot have one (insecure origin, no media devices). */

package/dist/voice-capture.js

@@ -15,7 +15,69 @@
 // `endedAt` is `startedAt` plus the decoded duration when the page can decode the recording, else the `stop` event's time.
 // Measured in Chromium only; a microphone that warms up after getUserMedia resolves (no audio yet when recording starts) would
 // make `startedAt` early by the warm-up.
+//
+// WAV first. Where the page has Web Audio, the capture records 16 kHz mono PCM WAV instead: a MediaRecorder webm carries the
+// browser's clock, and one stamped at 0 s then 3900 s (23/10/2026) was refused by every OpenAI transcription model ("Audio file
+// might be corrupted or unsupported"); a WAV has no timestamps, its length is its byte count. `start()` resolves only once the
+// first sound arrives (a fresh AudioContext can take a second or two), so a host that shows "recording" never loses the first
+// words; no sound within `firstSoundMs` refuses as `busy`. `startedAt` is the page time of that first buffer's first sample and
+// `endedAt` adds the samples' duration, so the clock no longer depends on MediaRecorder's late chunks. A ScriptProcessorNode, not
+// an AudioWorklet: a worklet is a module the page must serve, and a host's CSP may refuse one made from a blob. MediaRecorder
+// stays the fallback where there is no AudioContext.
 export const DEFAULT_MAX_VOICE_MS = 5 * 60_000;
+/** WAV recordings are 16 kHz mono 16-bit PCM: 32 kB per second. */
+export const WAV_RATE = 16_000;
+/** `input` (samples at `from` Hz) at `to` Hz, each output sample the mean of the input samples it covers. */
+export function downsample(input, from, to = WAV_RATE) {
+    if (from === to)
+        return Float32Array.from(input);
+    if (from < to)
+        throw new Error(`cannot upsample ${from} Hz to ${to} Hz`);
+    const ratio = from / to;
+    const out = new Float32Array(Math.floor(input.length / ratio));
+    for (let i = 0; i < out.length; i++) {
+        const start = Math.floor(i * ratio), end = Math.min(input.length, Math.floor((i + 1) * ratio));
+        let sum = 0;
+        for (let j = start; j < end; j++)
+            sum += input[j];
+        out[i] = end > start ? sum / (end - start) : 0;
+    }
+    return out;
+}
+/** The WAV file (16-bit PCM, mono) of `chunks` of samples at `rate` Hz, end to end, clipped to [-1, 1]. */
+export function encodeWav(chunks, rate = WAV_RATE) {
+    const length = chunks.reduce((n, chunk) => n + chunk.length, 0);
+    const view = new DataView(new ArrayBuffer(44 + length * 2));
+    const ascii = (at, text) => { for (let i = 0; i < text.length; i++)
+        view.setUint8(at + i, text.charCodeAt(i)); };
+    ascii(0, 'RIFF');
+    view.setUint32(4, 36 + length * 2, true);
+    ascii(8, 'WAVE');
+    ascii(12, 'fmt ');
+    view.setUint32(16, 16, true);
+    view.setUint16(20, 1, true);
+    view.setUint16(22, 1, true);
+    view.setUint32(24, rate, true);
+    view.setUint32(28, rate * 2, true);
+    view.setUint16(32, 2, true);
+    view.setUint16(34, 16, true);
+    ascii(36, 'data');
+    view.setUint32(40, length * 2, true);
+    let at = 44;
+    for (const chunk of chunks)
+        for (const sample of chunk) {
+            const v = Math.max(-1, Math.min(1, sample));
+            view.setInt16(at, v < 0 ? v * 0x8000 : v * 0x7fff, true);
+            at += 2;
+        }
+    return new Uint8Array(view.buffer);
+}
+/** The page's Web Audio context constructor, or null (Node, old browsers). */
+function browserAudioContext() {
+    const Context = globalThis.AudioContext
+        ?? globalThis.webkitAudioContext;
+    return typeof Context === 'function' ? () => new Context() : null;
+}
 /** Container types tried in order; the first the browser records wins. */
 export const VOICE_MIME_TYPES = ['audio/webm;codecs=opus', 'audio/webm', 'audio/mp4', 'audio/ogg;codecs=opus'];
 /** The browser's microphone, or null where the page cannot have one (insecure origin, no media devices). */
@@ -70,6 +132,157 @@ export function createVoiceCapture(options = {}) {
     let session = null;
     let opening = false;
     let cancelledWhileOpening = false;
+    const makeContext = options.audioContext === undefined ? browserAudioContext() : options.audioContext;
+    const firstSoundMs = options.firstSoundMs ?? 5_000;
+    let wav = null;
+    /** Stops capturing (the samples so far are kept), releases the microphone and closes the context. */
+    const endWav = (current, truncated) => {
+        if (truncated)
+            current.truncated = true;
+        if (current.ended)
+            return;
+        current.ended = true;
+        if (current.node) {
+            current.node.onaudioprocess = null;
+            current.node.disconnect();
+        }
+        current.source?.disconnect();
+        release(current.stream);
+        void current.context.close().catch(() => { });
+    };
+    /** MediaRecorder on an open microphone (`startedAt` read just before `start()`, see the clock above). */
+    function record(Recorder, stream) {
+        const supported = (type) => { try {
+            return typeof Recorder.isTypeSupported !== 'function' || Recorder.isTypeSupported(type);
+        }
+        catch {
+            return false;
+        } };
+        const preferred = VOICE_MIME_TYPES.find(supported);
+        let recorder;
+        try {
+            recorder = preferred ? new Recorder(stream, { mimeType: preferred }) : new Recorder(stream);
+        }
+        catch (error) {
+            release(stream);
+            return refused('unsupported', error instanceof Error ? error.message : String(error));
+        }
+        let settle;
+        const current = {
+            stream, recorder, mimeType: preferred ?? '', chunks: [], startedAt: null, stoppedAt: null, truncated: false, timer: null,
+            stopped: new Promise(resolve => { settle = resolve; }), cancelled: false,
+        };
+        recorder.addEventListener('dataavailable', event => { if (event.data && event.data.size > 0)
+            current.chunks.push(event.data); });
+        recorder.addEventListener('stop', () => { current.stoppedAt = now(); release(stream); settle(); });
+        recorder.addEventListener('error', () => { current.stoppedAt ??= now(); release(stream); settle(); });
+        try {
+            current.startedAt = now();
+            recorder.start(1000);
+        }
+        catch (error) {
+            release(stream);
+            return refused('failed', error instanceof Error ? error.message : String(error));
+        }
+        if (Number.isFinite(maxMs) && maxMs > 0)
+            current.timer = setTimeout(() => finish(current, true), maxMs);
+        session = current;
+        return { kind: 'recording' };
+    }
+    /** WAV through Web Audio: the context is made and resumed inside the person's click, before awaiting the microphone. */
+    async function startWav(makeContext, open, Recorder) {
+        opening = true;
+        cancelledWhileOpening = false;
+        let context;
+        try {
+            context = makeContext();
+        }
+        catch (error) {
+            opening = false;
+            return refused('unsupported', error instanceof Error ? error.message : String(error));
+        }
+        const resuming = context.resume().catch(() => { });
+        let stream;
+        try {
+            stream = await open({ audio: true });
+        }
+        catch (error) {
+            opening = false;
+            void context.close().catch(() => { });
+            return refusalOf(error);
+        }
+        let cancelled;
+        const current = {
+            stream, context, source: null, node: null, chunks: [], samples: 0, startedAt: null, truncated: false, cancelled: false, ended: false,
+            maxSamples: Number.isFinite(maxMs) && maxMs > 0 ? Math.floor((maxMs / 1000) * WAV_RATE) : Number.POSITIVE_INFINITY,
+            cancel: () => cancelled(),
+        };
+        const gone = new Promise(resolve => { cancelled = () => resolve('cancelled'); });
+        if (cancelledWhileOpening) {
+            opening = false;
+            endWav(current, false);
+            return { kind: 'refused', code: 'failed', reason: 'Cancelled before the microphone opened.' };
+        }
+        // A context the browser keeps suspended (no user activation: a press-and-hold begun on touchstart, which is not one) records
+        // nothing: that take is recorded by MediaRecorder on the microphone already open, as before WAV.
+        await Promise.race([resuming, new Promise(resolve => setTimeout(resolve, 500))]);
+        if (cancelledWhileOpening) {
+            opening = false;
+            endWav(current, false);
+            return { kind: 'refused', code: 'failed', reason: 'Cancelled before the microphone opened.' };
+        }
+        if (context.state !== 'running') {
+            void context.close().catch(() => { });
+            opening = false;
+            if (Recorder)
+                return record(Recorder, stream);
+            release(stream);
+            return refused('unsupported', 'audio is not allowed to start here');
+        }
+        let heard;
+        const sound = new Promise(resolve => { heard = () => resolve('heard'); });
+        try {
+            current.source = context.createMediaStreamSource(stream);
+            current.node = context.createScriptProcessor(4096, 1, 1);
+        }
+        catch (error) {
+            opening = false;
+            endWav(current, false);
+            return refused('unsupported', error instanceof Error ? error.message : String(error));
+        }
+        current.node.onaudioprocess = event => {
+            if (current.ended)
+                return;
+            const input = event.inputBuffer.getChannelData(0);
+            if (current.startedAt === null) {
+                current.startedAt = now() - (input.length / context.sampleRate) * 1000;
+                heard();
+            }
+            const chunk = downsample(input, context.sampleRate);
+            const room = current.maxSamples - current.samples;
+            const kept = chunk.length > room ? chunk.subarray(0, room) : chunk;
+            current.chunks.push(kept);
+            current.samples += kept.length;
+            if (current.samples >= current.maxSamples)
+                endWav(current, true);
+        };
+        current.source.connect(current.node);
+        current.node.connect(context.destination);
+        wav = current;
+        opening = false;
+        let timer;
+        const silent = new Promise(resolve => { timer = setTimeout(() => resolve('silent'), firstSoundMs); });
+        const outcome = await Promise.race([sound, silent, gone]);
+        clearTimeout(timer);
+        if (outcome === 'heard')
+            return { kind: 'recording' };
+        if (wav === current)
+            wav = null;
+        endWav(current, false);
+        return outcome === 'cancelled'
+            ? { kind: 'refused', code: 'failed', reason: 'Cancelled before the microphone opened.' }
+            : refused('busy', 'no sound from the microphone');
+    }
     const finish = (current, truncated) => {
         if (current.timer !== null) {
             clearTimeout(current.timer);
@@ -86,13 +299,15 @@ export function createVoiceCapture(options = {}) {
     };
     return {
         async start() {
-            if (session || opening)
+            if (session || wav || opening)
                 return { kind: 'refused', code: 'failed', reason: 'Already recording.' };
             const Recorder = globalThis.MediaRecorder;
             const open = options.getUserMedia ?? browserGetUserMedia();
             // No media devices on an insecure origin: say that, not "no microphone" (the person can fix the address, not the hardware).
             if (!open)
                 return refused(plainHttpPage() ? 'insecure' : 'unsupported');
+            if (makeContext)
+                return startWav(makeContext, open, typeof Recorder === 'function' ? Recorder : null);
             if (typeof Recorder !== 'function')
                 return refused('unsupported', 'no MediaRecorder');
             // getUserMedia is called synchronously from here, inside the person's click (no await before it), so browsers that tie the
@@ -112,47 +327,20 @@ export function createVoiceCapture(options = {}) {
                 release(stream);
                 return { kind: 'refused', code: 'failed', reason: 'Cancelled before the microphone opened.' };
             }
-            const supported = (type) => { try {
-                return typeof Recorder.isTypeSupported !== 'function' || Recorder.isTypeSupported(type);
-            }
-            catch {
-                return false;
-            } };
-            const preferred = VOICE_MIME_TYPES.find(supported);
-            let recorder;
-            try {
-                recorder = preferred ? new Recorder(stream, { mimeType: preferred }) : new Recorder(stream);
-            }
-            catch (error) {
-                opening = false;
-                release(stream);
-                return refused('unsupported', error instanceof Error ? error.message : String(error));
-            }
-            let settle;
-            const current = {
-                stream, recorder, mimeType: preferred ?? '', chunks: [], startedAt: null, stoppedAt: null, truncated: false, timer: null,
-                stopped: new Promise(resolve => { settle = resolve; }), cancelled: false,
-            };
-            recorder.addEventListener('dataavailable', event => { if (event.data && event.data.size > 0)
-                current.chunks.push(event.data); });
-            recorder.addEventListener('stop', () => { current.stoppedAt = now(); release(stream); settle(); });
-            recorder.addEventListener('error', () => { current.stoppedAt ??= now(); release(stream); settle(); });
-            try {
-                current.startedAt = now();
-                recorder.start(1000);
-            }
-            catch (error) {
-                opening = false;
-                release(stream);
-                return refused('failed', error instanceof Error ? error.message : String(error));
-            }
-            if (Number.isFinite(maxMs) && maxMs > 0)
-                current.timer = setTimeout(() => finish(current, true), maxMs);
-            session = current;
             opening = false;
-            return { kind: 'recording' };
+            return record(Recorder, stream);
         },
         async stop() {
+            const recorded = wav;
+            if (recorded) {
+                wav = null;
+                endWav(recorded, false);
+                if (recorded.cancelled || recorded.samples === 0 || recorded.startedAt === null)
+                    return null;
+                const audio = new Blob([encodeWav(recorded.chunks)], { type: 'audio/wav' });
+                const endedAt = recorded.startedAt + (recorded.samples / WAV_RATE) * 1000;
+                return { audio, mimeType: 'audio/wav', startedAt: recorded.startedAt, endedAt, truncated: recorded.truncated };
+            }
             const current = session;
             if (!current)
                 return null;
@@ -171,6 +359,14 @@ export function createVoiceCapture(options = {}) {
             return { audio, mimeType, startedAt, endedAt, truncated: current.truncated };
         },
         cancel() {
+            const recorded = wav;
+            if (recorded) {
+                wav = null;
+                recorded.cancelled = true;
+                recorded.chunks.length = 0;
+                endWav(recorded, false);
+                recorded.cancel();
+            }
             const current = session;
             if (opening)
                 cancelledWhileOpening = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-ui-kit",
-  "version": "0.4.13",
+  "version": "0.4.14",
   "license": "MIT",
   "private": false,
   "type": "module",
@@ -134,7 +134,7 @@
     }
   },
   "peerDependencies": {
-    "@hachej/boring-files": "^0.4.13",
+    "@hachej/boring-files": "^0.4.14",
     "@earendil-works/pi-durable": "~1.2.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",

package/r/agent-target.json

@@ -4,15 +4,15 @@
   "title": "Point and dictate on app data",
   "description": "Tap explicitly marked JSON app context, dictate once and show the same app agent’s native reply without opening chat. Host-controlled presentation; no feedback report or second controller.",
   "dependencies": [
-    "@hachej/boring-ui-kit@^0.4.13",
-    "@hachej/boring-feedback@^0.4.13",
+    "@hachej/boring-ui-kit@^0.4.14",
+    "@hachej/boring-feedback@^0.4.14",
     "@earendil-works/pi-durable@~1.2.0",
     "react@^19.0.0",
     "react-dom@^19.0.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/app-shell.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/pi-chat.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/app-shell.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/pi-chat.json",
     "button",
     "card",
     "message",

package/r/app-shell.json

@@ -4,21 +4,21 @@
   "title": "App shell: layouts, list/detail and agent layer",
   "description": "AppShell with three layouts. B \"workspace\" puts a ListDetail on a screen (phone: the list, then the detail as a stack step with Back; wide: a 20rem list and the detail side by side, sidebar as an icon rail). C \"chat\" wraps the app's own AgentWorkspace (untouched, passed as the nav item's render; install the pi-app item yourself) in the same sidebar, account menu and header; it takes no shell agent. A \"screen\": one screen at a time, every screen kept mounted. On a phone bottom tabs (at most four; more give three plus a « Plus » sheet) and an avatar button that opens the account sheet; on a wide screen the shadcn sidebar (icon rail, NavUser). One header per screen through useScreenHeader (title, subtitle, back, up to two actions, the rest behind « … »). The account menu holds « Améliorer l'app » (the improve agent), the app's own entries and sign out. AppSheet is the one bottom sheet (one open at a time, Back closes it). It mounts the AgentLayer: one agent's PiChat above the app (phone: a drawer with peek, half and full snap points; wide: a right panel), the improve agent in the same layer, optional push-to-talk and point mode. Also useAgentContext and readAgentContext (the screen on show travels as `context` with each submit) and useBackLayer, the one Back manager. Built on explicitly pinned Base UI drawer and dropdown-menu recipes, plus the sidebar and avatar of the host's own shadcn style.",
   "dependencies": [
-    "@hachej/boring-feedback@^0.4.13",
-    "@hachej/boring-ui-kit@^0.4.13",
+    "@hachej/boring-feedback@^0.4.14",
+    "@hachej/boring-ui-kit@^0.4.14",
     "@base-ui/react@^1.9.0",
     "react@^19.0.0",
     "react-dom@^19.0.0",
     "lucide-react@^1.51.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/pi-chat.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/pi-chat-plugins.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/pi-chat-voice.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/dock.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/feedback.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/utils.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/button.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/pi-chat.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/pi-chat-plugins.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/pi-chat-voice.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/dock.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/feedback.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/utils.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/button.json",
     "drawer",
     "sidebar",
     "avatar",

package/r/board-viewer.json

@@ -4,16 +4,16 @@
   "title": "Board viewer",
   "description": "A board@1 artifact kind for *.board.json. Lazy native tldraw projection of maquette screens, sandboxed HTML mock-ups, goto arrows and notes. Conditional board-file autosave; phone viewing without accidental frame edits. Hosts supply their resource client, asset URLs and license key.",
   "dependencies": [
-    "@hachej/boring-ui-kit@^0.4.13",
-    "@hachej/boring-files@^0.4.13",
+    "@hachej/boring-ui-kit@^0.4.14",
+    "@hachej/boring-files@^0.4.14",
     "react@^19.0.0",
     "lucide-react@1.51.0",
     "tldraw@5.5.2"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/maquette-viewer.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/mockup-viewer.json",
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/pi-artifacts.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/maquette-viewer.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/mockup-viewer.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/pi-artifacts.json",
     "button",
     "alert",
     "card",

package/r/button.json

@@ -9,7 +9,7 @@
     "lucide-react@^1.51.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/utils.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/utils.json",
     "dropdown-menu",
     "button",
     "toggle",

package/r/diagram-viewer.json

@@ -8,7 +8,7 @@
     "lucide-react@^1.51.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/theme.json",
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/theme.json",
     "alert",
     "badge"
   ],

package/r/dock.json

@@ -7,7 +7,7 @@
     "react@^19.0.0"
   ],
   "registryDependencies": [
-    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.13/r/utils.json"
+    "https://cdn.jsdelivr.net/npm/@hachej/boring-ui-kit@0.4.14/r/utils.json"
   ],
   "files": [
     {