@burdenoff/fe-libs 2026.925.3 → 2026.925.4

package/dist/shared/assistant/turnTimeline.d.ts

@@ -0,0 +1,283 @@
+/**
+ * ★★ Where a turn's time goes — measured before anything is optimised
+ * (BOFF-7801).
+ *
+ * First answers took 55–150s+ in production, and nobody could say which part
+ * of that was the sandbox starting, a dead sandbox being probed, the model
+ * thinking, the poll noticing, our own bookkeeping, or the voice fetching
+ * audio. This records each milestone of a turn as it happens, so the slow part
+ * is measured instead of guessed.
+ *
+ * The chain, in order:
+ *
+ *   speechEnded       the last time the heard words CHANGED (voice only)
+ *   graceStarted      the correction grace began — the last result that re-armed
+ *                     it; after speechEnded when the recogniser re-commits late
+ *   graceEnded        the correction grace ran out; the turn was submitted
+ *   handedOver        its attachments settled and it went to the panel (voice)
+ *   accepted          the panel took the turn: the question is on screen
+ *   cleared           the send-time checks passed (mode access, write consent)
+ *   attemptStarted    this attempt at a runtime began (again, on a retry)
+ *   provisionStarted  no reusable sandbox — making room for a new one starts here
+ *   createRequested   the new sandbox was requested (after releasing old ones)
+ *   sandboxRunning    the created sandbox is running (cold)
+ *   serviceReady      the assistant service inside it answers (cold)
+ *   runtimeReady      a sandbox and a session are ready to take the prompt
+ *   promptSent        the sandbox accepted the prompt
+ *   lastQuietPoll     the last poll that saw nothing — with firstOutput, the
+ *                     UPPER bound of how late polling noticed the output
+ *   firstOutput       the first poll that saw anything to show (a tool line too)
+ *   firstText         the first poll that saw answer TEXT — prose not followed
+ *                     by a tool call, confirmed when the turn completes, so
+ *                     pre-tool narration does not count. In modes whose
+ *                     narration IS the answer (BigConsole's build log), the
+ *                     first narration: group reports by `mode`
+ *   answerDone        the poll that saw the answer complete
+ *   complete          the turn ended (after artifacts and the credit report)
+ *   ttsStarted        auto-speak handed the reply to the speech engine
+ *   firstAudio        the engine reported sound actually started
+ *
+ * ★ `graceStarted → graceEnded` is the 2s correction grace, and it is KEPT: it
+ * stops a pause mid-sentence from submitting half a question. It is a segment
+ * of its own so it can never be "optimised" away by accident — and the
+ * recogniser's own endpointing (`speechEnded → graceStarted`, 0.5–1.5s and
+ * longer on Android) is kept OUT of it, because that one can be optimised.
+ *
+ * ★ Filler is never output: the progress `content` is model output only
+ * (BOFF-7277) and the waiting copy is drawn by the bubble from the stage.
+ *
+ * ★ A turn whose first attempt fails recoverably is retried under the SAME id.
+ * `restartAttempt` files the first attempt's marks under `attempts` so the
+ * second records its own — mixed attempts are not a timeline.
+ *
+ * Times are `performance.now()` — monotonic, comparable within the page. The
+ * event is visible to EVERY script on the page, so it carries timings and
+ * coarse dimensions only: never message text, never tenant, user, workspace or
+ * conversation ids. Delivery is asynchronous, so a listener never runs inside
+ * the step it measures.
+ */
+export declare const TURN_MILESTONES: readonly ["speechEnded", "graceStarted", "graceEnded", "handedOver", "accepted", "cleared", "attemptStarted", "provisionStarted", "createRequested", "sandboxRunning", "serviceReady", "runtimeReady", "promptSent", "lastQuietPoll", "firstOutput", "firstText", "answerDone", "complete", "ttsStarted", "firstAudio"];
+export type TurnMilestone = (typeof TURN_MILESTONES)[number];
+/**
+ * How the runtime was found:
+ * - `warm`: a remembered sandbox with a fresh readiness proof, session reused
+ * - `new-session`: that sandbox, but a new session
+ * - `probed`: a RUNNING sandbox was reused only after a reachability probe
+ * - `adopted`: a boot was joined and waited out — the sandbox was listed
+ *   PROVISIONING/PENDING, or its service answered "not up yet" during the
+ *   probe (a reload or second tab mid-cold-start; a remembered sandbox that
+ *   restarted or woke). ★ Limits: a single transient proxy 502 also reads as
+ *   adopted, and a remembered sandbox reported RUNNING only once serving
+ *   gives no signal at all — so `probed` can still hold a joined boot: read
+ *   its `runtime` segment, not just the label
+ * - `cold`: a sandbox was created
+ */
+export type TurnRuntime = "warm" | "new-session" | "probed" | "adopted" | "cold";
+/**
+ * Counted as the person was SHOWN it (`classifyTurnFailure`):
+ * - `refused`: a usage wall, a permission refusal (server 403/429 included),
+ *   or a confirmation to give — a decision, not a breakdown;
+ * - `failed`: a temporary failure, including a mode-access check that had not
+ *   answered yet;
+ * - `timedOut`: the client's stream budget ran out before the answer finished.
+ * Only `answered` turns carry `firstText`; a timed-out turn's unconfirmed text
+ * is not recorded.
+ */
+export type TurnTimelineOutcome = "answered" | "timedOut" | "refused" | "failed" | "stopped";
+export interface TurnDimensions {
+    channel: "chat" | "voice";
+    mode: string;
+    product: string;
+    /** The reply language the turn asked for. */
+    language: string;
+    device: "touch" | "pointer" | "unknown";
+    /** Auto chose the mode (an Auto escalation can cost a cold start). */
+    routedByAuto: boolean;
+}
+/** What one attempt found out. */
+export interface TurnAttemptFacts {
+    runtime?: TurnRuntime;
+    /** The model called at least one tool on the way to its answer. */
+    usedTools?: boolean;
+    /** A reuse probe failed — a dead sandbox cost time before a new one. */
+    deadSandboxProbe?: boolean;
+}
+export interface TurnAttempt extends TurnAttemptFacts {
+    at: Partial<Record<TurnMilestone, number>>;
+    /** When the attempt was abandoned for the next one: its time to failure. */
+    endedAt?: number;
+}
+export interface TurnTimeline extends TurnDimensions, TurnAttemptFacts {
+    turnId: string;
+    at: Partial<Record<TurnMilestone, number>>;
+    /** Earlier attempts of a retried turn, oldest first. */
+    attempts?: TurnAttempt[];
+    retried?: boolean;
+    outcome?: TurnTimelineOutcome;
+}
+/** Marks a voice turn brings with it, taken before the panel has an id for it. */
+export type VoiceTurnTiming = Partial<Record<"speechEnded" | "graceStarted" | "graceEnded" | "handedOver", number>>;
+/** Announced on `window` with a copy of the timeline each time it changes. */
+export declare const TURN_TIMELINE_EVENT = "burdenoff:assistant-turn-timeline";
+export declare function turnClockMs(): number;
+/** Coarse pointer = a finger. The split the latency report needs, not a device model. */
+export declare function detectTurnDevice(): TurnDimensions["device"];
+/**
+ * Start recording a turn. `carried` holds marks taken before the turn had an
+ * id — a voice turn's end of speech, end of grace and hand-over.
+ *
+ * Idempotent: beginning a recorded turn again does nothing, so nothing can
+ * reset a clock a turn is being measured against.
+ */
+export declare function beginTurn(turnId: string, dimensions: TurnDimensions, carried?: VoiceTurnTiming): void;
+/**
+ * Record a milestone. The FIRST time wins — the poll that first saw output is
+ * the one that counts, however many polls follow — and a turn that was never
+ * begun is ignored, so "Listen" on yesterday's answer is not a turn.
+ */
+export declare function markTurn(turnId: string, milestone: TurnMilestone, at?: number): void;
+/** Facts about the turn learnt along the way. The first answer to each stands. */
+export declare function describeTurn(turnId: string, facts: TurnAttemptFacts & Pick<TurnTimeline, "outcome">): void;
+/**
+ * The turn is starting over on a new runtime. File this attempt's marks and
+ * facts under `attempts`, stamped with when it ended, and clear them, so the
+ * next attempt records its own. What the person did — speech, hand-over,
+ * acceptance, the checks — stays.
+ */
+export declare function restartAttempt(turnId: string, at?: number): void;
+export declare function turnTimeline(turnId: string): TurnTimeline | undefined;
+/** Newest last. For a console or a measurement run. */
+export declare function recentTurnTimelines(): TurnTimeline[];
+/** Tests only. */
+export declare function resetTurnTimelines(): void;
+/**
+ * The named spans of a turn, each present only when both ends were recorded
+ * in order. The first group is contiguous steps; the `to*` and speech totals
+ * are what a person actually feels.
+ */
+export declare const TURN_SEGMENTS: readonly [{
+    readonly name: "endpointing";
+    readonly from: "speechEnded";
+    readonly to: "graceStarted";
+}, {
+    readonly name: "grace";
+    readonly from: "graceStarted";
+    readonly to: "graceEnded";
+}, {
+    readonly name: "uploadWait";
+    readonly from: "graceEnded";
+    readonly to: "handedOver";
+}, {
+    readonly name: "queue";
+    readonly from: "handedOver";
+    readonly to: "accepted";
+}, {
+    readonly name: "checks";
+    readonly from: "accepted";
+    readonly to: "cleared";
+}, {
+    readonly name: "runtime";
+    readonly from: "attemptStarted";
+    readonly to: "runtimeReady";
+}, {
+    readonly name: "reuseCheck";
+    readonly from: "attemptStarted";
+    readonly to: "provisionStarted";
+}, {
+    readonly name: "slotRelease";
+    readonly from: "provisionStarted";
+    readonly to: "createRequested";
+}, {
+    readonly name: "sandboxStart";
+    readonly from: "createRequested";
+    readonly to: "sandboxRunning";
+}, {
+    readonly name: "serviceStart";
+    readonly from: "sandboxRunning";
+    readonly to: "serviceReady";
+}, {
+    readonly name: "prompt";
+    readonly from: "runtimeReady";
+    readonly to: "promptSent";
+}, {
+    readonly name: "model";
+    readonly from: "promptSent";
+    readonly to: "firstOutput";
+}, {
+    readonly name: "pollLag";
+    readonly from: "lastQuietPoll";
+    readonly to: "firstOutput";
+}, {
+    readonly name: "finish";
+    readonly from: "firstOutput";
+    readonly to: "answerDone";
+}, {
+    readonly name: "post";
+    readonly from: "answerDone";
+    readonly to: "complete";
+}, {
+    readonly name: "speechQueue";
+    readonly from: "complete";
+    readonly to: "ttsStarted";
+}, {
+    readonly name: "speechFetch";
+    readonly from: "ttsStarted";
+    readonly to: "firstAudio";
+}, {
+    readonly name: "toFirstOutput";
+    readonly from: "accepted";
+    readonly to: "firstOutput";
+}, {
+    readonly name: "toFirstText";
+    readonly from: "accepted";
+    readonly to: "firstText";
+}, {
+    readonly name: "toAnswer";
+    readonly from: "accepted";
+    readonly to: "answerDone";
+}, {
+    readonly name: "toComplete";
+    readonly from: "accepted";
+    readonly to: "complete";
+}, {
+    readonly name: "toFirstAudio";
+    readonly from: "accepted";
+    readonly to: "firstAudio";
+}, {
+    readonly name: "processingToFirstAudio";
+    readonly from: "graceEnded";
+    readonly to: "firstAudio";
+}, {
+    readonly name: "heardAfterSpeaking";
+    readonly from: "speechEnded";
+    readonly to: "firstAudio";
+}];
+export type TurnSegmentName = (typeof TURN_SEGMENTS)[number]["name"];
+/**
+ * A segment whose end came BEFORE its start is left out: it can only be a
+ * wiring fault, and a negative duration averaged in would hide the slow case.
+ */
+export declare function turnSegments(timeline: Pick<TurnTimeline, "at">): Partial<Record<TurnSegmentName, number>>;
+export interface SegmentStats {
+    n: number;
+    median: number;
+    /** Nearest-rank 90th percentile — "the slow case", reported apart from the median. */
+    p90: number;
+    max: number;
+}
+export declare function segmentStats(values: number[]): SegmentStats | undefined;
+/**
+ * The turns whose segments compare: answered, on one attempt. A retried,
+ * failed, refused, stopped, timed-out or unfinished turn is not averaged into
+ * steps it did not take. ★ A retried turn is often the slowest a person felt:
+ * report it too — its own group, its felt totals (`toAnswer`, `toFirstAudio`)
+ * — by passing `(t) => t.retried === true && t.outcome === "answered"` as
+ * `include` (and the retried turns that did not answer, by count).
+ */
+export declare function isComparableTurn(timeline: TurnTimeline): boolean;
+/**
+ * Median and slow case per segment, split by whatever `groupOf` says — warm /
+ * cold, tool / no tool, language, device, channel, or any combination.
+ */
+export declare function summariseTurnTimelines(timelines: readonly TurnTimeline[], groupOf: (timeline: TurnTimeline) => string, include?: (timeline: TurnTimeline) => boolean): Record<string, Partial<Record<TurnSegmentName, SegmentStats>>>;
+//# sourceMappingURL=turnTimeline.d.ts.map

package/dist/shared/assistant/turnTimeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnTimeline.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/turnTimeline.ts"],"names":[],"mappings":"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"}

package/dist/shared/assistant/turnTimeline.js

@@ -0,0 +1,291 @@
+//#region src/shared/assistant/turnTimeline.ts
+var e = [
+	"speechEnded",
+	"graceStarted",
+	"graceEnded",
+	"handedOver",
+	"accepted",
+	"cleared",
+	"attemptStarted",
+	"provisionStarted",
+	"createRequested",
+	"sandboxRunning",
+	"serviceReady",
+	"runtimeReady",
+	"promptSent",
+	"lastQuietPoll",
+	"firstOutput",
+	"firstText",
+	"answerDone",
+	"complete",
+	"ttsStarted",
+	"firstAudio"
+], t = [
+	"attemptStarted",
+	"provisionStarted",
+	"createRequested",
+	"sandboxRunning",
+	"serviceReady",
+	"runtimeReady",
+	"promptSent",
+	"lastQuietPoll",
+	"firstOutput",
+	"firstText",
+	"answerDone"
+], n = "burdenoff:assistant-turn-timeline", r = 50, i = /* @__PURE__ */ new Map();
+function a() {
+	try {
+		if (typeof performance < "u" && typeof performance?.now == "function") return performance.now();
+	} catch {}
+	return Date.now();
+}
+function o() {
+	try {
+		let e = typeof window > "u" ? null : window;
+		return !e || typeof e.matchMedia != "function" ? "unknown" : e.matchMedia("(pointer: coarse)").matches ? "touch" : "pointer";
+	} catch {
+		return "unknown";
+	}
+}
+function s(e) {
+	return {
+		...e,
+		at: { ...e.at },
+		...e.attempts ? { attempts: e.attempts.map((e) => ({
+			...e,
+			at: { ...e.at }
+		})) } : {}
+	};
+}
+function c(e) {
+	let t = s(e), r = () => {
+		try {
+			let e = typeof window > "u" ? null : window;
+			if (!e || typeof e.dispatchEvent != "function" || typeof CustomEvent != "function") return;
+			e.dispatchEvent(new CustomEvent(n, { detail: t }));
+		} catch {}
+	};
+	typeof queueMicrotask == "function" ? queueMicrotask(r) : r();
+}
+function l(e, t, n) {
+	if (i.has(e)) return;
+	let a = {};
+	n?.speechEnded !== void 0 && (a.speechEnded = n.speechEnded), n?.graceStarted !== void 0 && (a.graceStarted = n.graceStarted), n?.graceEnded !== void 0 && (a.graceEnded = n.graceEnded), n?.handedOver !== void 0 && (a.handedOver = n.handedOver);
+	let o = {
+		turnId: e,
+		...t,
+		at: a
+	};
+	for (i.set(e, o); i.size > r;) {
+		let e = i.keys().next().value;
+		if (e === void 0) break;
+		i.delete(e);
+	}
+	c(o);
+}
+function u(e, t, n = a()) {
+	let r = i.get(e);
+	!r || r.at[t] !== void 0 || (r.at[t] = n, c(r));
+}
+function d(e, t) {
+	let n = i.get(e);
+	if (!n) return;
+	let r = !1;
+	t.runtime !== void 0 && n.runtime === void 0 && (n.runtime = t.runtime, r = !0), t.usedTools !== void 0 && n.usedTools === void 0 && (n.usedTools = t.usedTools, r = !0), t.deadSandboxProbe !== void 0 && n.deadSandboxProbe === void 0 && (n.deadSandboxProbe = t.deadSandboxProbe, r = !0), t.outcome !== void 0 && n.outcome === void 0 && (n.outcome = t.outcome, r = !0), r && c(n);
+}
+function f(e, n = a()) {
+	let r = i.get(e);
+	if (!r) return;
+	let o = {
+		at: {},
+		endedAt: n
+	};
+	for (let e of t) {
+		let t = r.at[e];
+		t !== void 0 && (o.at[e] = t, delete r.at[e]);
+	}
+	r.runtime !== void 0 && (o.runtime = r.runtime), r.usedTools !== void 0 && (o.usedTools = r.usedTools), r.deadSandboxProbe !== void 0 && (o.deadSandboxProbe = r.deadSandboxProbe), delete r.runtime, delete r.usedTools, delete r.deadSandboxProbe, r.attempts = [...r.attempts ?? [], o], r.retried = !0, c(r);
+}
+function p(e) {
+	let t = i.get(e);
+	return t ? s(t) : void 0;
+}
+function m() {
+	return [...i.values()].map(s);
+}
+function h() {
+	i.clear();
+}
+var g = [
+	{
+		name: "endpointing",
+		from: "speechEnded",
+		to: "graceStarted"
+	},
+	{
+		name: "grace",
+		from: "graceStarted",
+		to: "graceEnded"
+	},
+	{
+		name: "uploadWait",
+		from: "graceEnded",
+		to: "handedOver"
+	},
+	{
+		name: "queue",
+		from: "handedOver",
+		to: "accepted"
+	},
+	{
+		name: "checks",
+		from: "accepted",
+		to: "cleared"
+	},
+	{
+		name: "runtime",
+		from: "attemptStarted",
+		to: "runtimeReady"
+	},
+	{
+		name: "reuseCheck",
+		from: "attemptStarted",
+		to: "provisionStarted"
+	},
+	{
+		name: "slotRelease",
+		from: "provisionStarted",
+		to: "createRequested"
+	},
+	{
+		name: "sandboxStart",
+		from: "createRequested",
+		to: "sandboxRunning"
+	},
+	{
+		name: "serviceStart",
+		from: "sandboxRunning",
+		to: "serviceReady"
+	},
+	{
+		name: "prompt",
+		from: "runtimeReady",
+		to: "promptSent"
+	},
+	{
+		name: "model",
+		from: "promptSent",
+		to: "firstOutput"
+	},
+	{
+		name: "pollLag",
+		from: "lastQuietPoll",
+		to: "firstOutput"
+	},
+	{
+		name: "finish",
+		from: "firstOutput",
+		to: "answerDone"
+	},
+	{
+		name: "post",
+		from: "answerDone",
+		to: "complete"
+	},
+	{
+		name: "speechQueue",
+		from: "complete",
+		to: "ttsStarted"
+	},
+	{
+		name: "speechFetch",
+		from: "ttsStarted",
+		to: "firstAudio"
+	},
+	{
+		name: "toFirstOutput",
+		from: "accepted",
+		to: "firstOutput"
+	},
+	{
+		name: "toFirstText",
+		from: "accepted",
+		to: "firstText"
+	},
+	{
+		name: "toAnswer",
+		from: "accepted",
+		to: "answerDone"
+	},
+	{
+		name: "toComplete",
+		from: "accepted",
+		to: "complete"
+	},
+	{
+		name: "toFirstAudio",
+		from: "accepted",
+		to: "firstAudio"
+	},
+	{
+		name: "processingToFirstAudio",
+		from: "graceEnded",
+		to: "firstAudio"
+	},
+	{
+		name: "heardAfterSpeaking",
+		from: "speechEnded",
+		to: "firstAudio"
+	}
+];
+function _(e) {
+	let t = {};
+	for (let { name: n, from: r, to: i } of g) {
+		let a = e.at[r], o = e.at[i];
+		a !== void 0 && o !== void 0 && o >= a && (t[n] = o - a);
+	}
+	return t;
+}
+function v(e, t) {
+	return e[Math.max(1, Math.ceil(t * e.length)) - 1];
+}
+function y(e) {
+	if (!e.length) return;
+	let t = [...e].sort((e, t) => e - t), n = Math.floor(t.length / 2), r = t.length % 2 ? t[n] : (t[n - 1] + t[n]) / 2;
+	return {
+		n: t.length,
+		median: r,
+		p90: v(t, .9),
+		max: t[t.length - 1]
+	};
+}
+function b(e) {
+	return e.outcome === "answered" && !e.retried;
+}
+function x(e, t, n = b) {
+	let r = /* @__PURE__ */ new Map();
+	for (let i of e) {
+		if (!n(i)) continue;
+		let e = t(i), a = r.get(e) ?? /* @__PURE__ */ new Map();
+		r.set(e, a);
+		let o = _(i);
+		for (let { name: e } of g) {
+			let t = o[e];
+			if (t === void 0) continue;
+			let n = a.get(e) ?? [];
+			n.push(t), a.set(e, n);
+		}
+	}
+	let i = {};
+	for (let [e, t] of r) {
+		let n = {};
+		for (let [e, r] of t) {
+			let t = y(r);
+			t && (n[e] = t);
+		}
+		i[e] = n;
+	}
+	return i;
+}
+//#endregion
+export { e as TURN_MILESTONES, g as TURN_SEGMENTS, n as TURN_TIMELINE_EVENT, l as beginTurn, d as describeTurn, o as detectTurnDevice, b as isComparableTurn, u as markTurn, m as recentTurnTimelines, h as resetTurnTimelines, f as restartAttempt, y as segmentStats, x as summariseTurnTimelines, a as turnClockMs, _ as turnSegments, p as turnTimeline };

package/dist/shared/assistant/ui/AssistantChatArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AssistantChatArea.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/ui/AssistantChatArea.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,EAAE,EACR,MAAM,OAAO,CAAC;AAkGf,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAyDvE;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACpC;AAED,eAAO,MAAM,iBAAiB,EAAE,EAAE,CAAC,sBAAsB,CAqgFxD,CAAC"}
+{"version":3,"file":"AssistantChatArea.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/ui/AssistantChatArea.tsx"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,EAAE,EACR,MAAM,OAAO,CAAC;AAmHf,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAyDvE;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;;;;;;;OAYG;IACH,WAAW,CAAC,EAAE,oBAAoB,CAAC;CACpC;AAED,eAAO,MAAM,iBAAiB,EAAE,EAAE,CAAC,sBAAsB,CAgqFxD,CAAC"}