@burdenoff/fe-libs 2026.825.7 → 2026.903.1

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

@@ -12,4 +12,6 @@ export { isQuotaExhaustedError } from './gatewayClient';
 export { buildProgress, getAssistantMedia, sanitize, isRecoverable, mergeMessagesById, mapSessionToHistory, } from './progress';
 export { buildPromptRequestBody, findExistingSandbox, createAssistantSandbox, waitForSandboxRunning, waitForAssistantServiceReady, createAssistantSession, getAssistantSession, sendAssistantPromptAsync, getAssistantMessages, getAssistantStreamAccess, extendAssistantSandboxTTL, sendHeartbeat, getAssistantArtifacts, downloadAssistantArtifact, checkAssistantAiCredits, reportAssistantAiTokenUsage, } from './api';
 export type { AssistantMode, AssistantPromptPart, PageContext, SandboxAssistantConfig, SandboxAssistantTransport, AssistantSendArgs, PrewarmLevel, AssistantRawMessage, AssistantRawMessagePart, AssistantWidgetMessage, AssistantArtifact, AssistantSandboxAuthContext, AssistantSessionInfo, DownloadedAssistantArtifact, StreamAccess, } from './types';
+export { isVoiceTurn, voiceSessionIdOf, voiceMarker, chatTurns, voiceTurnsOnly, groupBySession, groupConsecutiveBySession, } from './voice/turnVisibility';
+export type { VoiceSessionGroup, VoiceTranscriptTurn } from './voice/turnVisibility';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAKpB,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,OAAO,CAAC;AAEf,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,GACb,MAAM,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,4BAA4B,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,EAAE,+BAA+B,EAAE,MAAM,mCAAmC,CAAC;AACpF,OAAO,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AACpD,OAAO,EAAE,qBAAqB,EAAE,MAAM,iBAAiB,CAAC;AACxD,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,QAAQ,EACR,aAAa,EACb,iBAAiB,EACjB,mBAAmB,GACpB,MAAM,YAAY,CAAC;AAKpB,OAAO,EACL,sBAAsB,EACtB,mBAAmB,EACnB,sBAAsB,EACtB,qBAAqB,EACrB,4BAA4B,EAC5B,sBAAsB,EACtB,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,EACpB,wBAAwB,EACxB,yBAAyB,EACzB,aAAa,EACb,qBAAqB,EACrB,yBAAyB,EACzB,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,OAAO,CAAC;AAEf,YAAY,EACV,aAAa,EACb,mBAAmB,EACnB,WAAW,EACX,sBAAsB,EACtB,yBAAyB,EACzB,iBAAiB,EACjB,YAAY,EACZ,mBAAmB,EACnB,uBAAuB,EACvB,sBAAsB,EACtB,iBAAiB,EACjB,2BAA2B,EAC3B,oBAAoB,EACpB,2BAA2B,EAC3B,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,OAAO,EACL,WAAW,EACX,gBAAgB,EAChB,WAAW,EACX,SAAS,EACT,cAAc,EACd,cAAc,EACd,yBAAyB,GAC1B,MAAM,wBAAwB,CAAC;AAChC,YAAY,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/shared/assistant/voice/turnVisibility.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Which surface does an assistant turn belong to — typed chat, or live voice?
+ *
+ * Shared by every product, for the same reason the transport is: voice was built
+ * as an overlay over the chat thread in the first product that needed it, so
+ * both surfaces write into ONE conversation. Without a marker there is no way to
+ * tell a spoken turn from a typed one once it is stored, and every voice
+ * exchange shows up in the typed thread.
+ *
+ * One marker fixes both directions:
+ *  - the chat panel hides turns that happened in voice
+ *  - the voice panel shows ONLY turns that happened in voice
+ *
+ * ★ Deliberately a DISPLAY split, not separate persistence. It survives a reload
+ * because the chat transcript is never rehydrated from the backend — the store is
+ * the only source of truth for what either panel shows. The backend session stays
+ * shared, so the model keeps full context across both surfaces, which is what
+ * makes "carry on where we left off" work. Genuinely separate backend sessions
+ * are a larger change and would cost that.
+ *
+ * ★ Product-agnostic by construction: it knows about turns and surfaces, never
+ * about crops, workflows or nodes. Nothing here needs to change for a product
+ * whose modes are `fluidgrids-node` rather than `api-calls`.
+ */
+interface TurnLike {
+    metadata?: ({
+        voice?: boolean;
+        voiceSessionId?: string;
+    } & Record<string, unknown>) | undefined;
+}
+/** True when this turn happened inside a live voice session. */
+export declare function isVoiceTurn(message: TurnLike): boolean;
+/**
+ * WHICH voice session produced this turn, if we know.
+ *
+ * ★ `undefined` is a real answer, not a failure: every spoken turn recorded
+ * before session ids existed carries `voice: true` and nothing else, and those
+ * conversations are in users' localStorage today. It means "some earlier
+ * session" and must never be read as "not spoken" — `isVoiceTurn` remains the
+ * only thing that decides which surface a turn belongs to.
+ */
+export declare function voiceSessionIdOf(message: TurnLike): string | undefined;
+/**
+ * The marker as a fragment to spread into a message's `metadata`.
+ *
+ * ★ `patchMessage` REPLACES `metadata` instead of merging it, so every write
+ * that rebuilds the object has to re-assert this or the turn silently demotes
+ * itself to a chat turn. That is exactly what shipped: the marker was stamped
+ * at creation and destroyed the instant the reply completed, so a spoken answer
+ * appeared in the typed thread AND disappeared from the voice transcript at the
+ * same moment — the transcript could only ever show the user's questions.
+ *
+ * Spreading one helper at all four sites is what keeps them from drifting;
+ * `voiceMarkerCallSitesAreComplete` in the test file fails the build if a new
+ * metadata write forgets it.
+ *
+ * ★ Takes the SESSION ID rather than a boolean, and stamps both fields from it.
+ * There used to be a separate `dictated` flag that call sites passed straight
+ * through, which made it possible to mark a turn as spoken while recording no
+ * session — a state with no meaning that only the transcript would ever notice.
+ * One argument means the two can never disagree.
+ *
+ * An absent id yields an EMPTY object, so a typed turn gets no marker at all:
+ * `chatTurns` is allow-by-default, and a stray `voice: false` would be a second
+ * way of saying the same thing.
+ */
+export declare function voiceMarker(sessionId: string | undefined): {
+    voice?: true;
+    voiceSessionId?: string;
+};
+/**
+ * The turns the CHAT panel should show: everything that was not spoken.
+ *
+ * Untagged turns are treated as chat, so every conversation recorded before the
+ * marker existed keeps rendering exactly as it did.
+ */
+export declare function chatTurns<T extends TurnLike>(messages: readonly T[]): T[];
+/**
+ * The turns the VOICE panel should show: only what was spoken.
+ *
+ * This is also what scopes the voice transcript to the session. Previously it
+ * took the last six messages of the whole conversation, so opening voice on an
+ * existing thread immediately painted typed replies — the wall of raw markdown
+ * in the operator's screenshot.
+ */
+export declare function voiceTurnsOnly<T extends TurnLike>(messages: readonly T[]): T[];
+/** One microphone-on-to-End, and the turns it produced, oldest first. */
+export interface VoiceSessionGroup<T> {
+    /**
+     * `undefined` for turns recorded before session ids existed. Rendered as one
+     * leading group rather than dropped — it is real history the user spoke.
+     */
+    sessionId: string | undefined;
+    turns: T[];
+}
+/**
+ * Split spoken turns into the sessions that produced them.
+ *
+ * The transcript shows a conversation's whole spoken history, which is the more
+ * useful of the two options — you can go back to what you asked last time — but
+ * run together it reads as one long exchange, and a question from a session
+ * three days ago looks like it was just asked. Grouping is what makes showing
+ * everything honest.
+ *
+ * ★ Groups by RUNS, not by collecting every turn with the same id. Turns are
+ * stored in the order they happened, so a run IS a session; gathering by id
+ * instead would silently reorder history if two sessions ever interleaved, and
+ * would hide it rather than show it if they did.
+ *
+ * ★ Consecutive un-stamped turns collapse into a single leading group. Treating
+ * each as its own session would print a divider between every pre-existing turn
+ * — one long exchange shattered into fragments, which is worse than the
+ * undivided version this is meant to fix.
+ */
+export declare function groupBySession<T extends TurnLike>(turns: readonly T[]): VoiceSessionGroup<T>[];
+/**
+ * The same grouping for turns that have already been flattened for display.
+ *
+ * The transcript renders `{id, role, text}`, not `Message`, so it cannot reach
+ * `metadata`. Passing the extractor keeps ONE implementation of the run logic
+ * instead of a second copy that drifts — the subtle part is the `undefined`
+ * merge, and having it in two places is how one of them stops doing it.
+ */
+export declare function groupConsecutiveBySession<T>(turns: readonly T[], sessionIdOf: (turn: T) => string | undefined): VoiceSessionGroup<T>[];
+/**
+ * A spoken turn flattened for display.
+ *
+ * ★ Shared by every component between the chat area and the transcript, so the
+ * session id is carried in the TYPE and not merely at runtime. The intermediate
+ * props used to declare `{id, role, text}` while the objects flowing through
+ * happened to have more: it compiled, and the dividers worked, purely because
+ * JavaScript keeps the extra property. Any future refactor that rebuilt one of
+ * those objects would have dropped the id and silently run every session back
+ * together — the exact defect this field was added to fix, reintroduced with no
+ * type error.
+ */
+export interface VoiceTranscriptTurn {
+    id: string;
+    role: 'user' | 'assistant';
+    text: string;
+    /**
+     * When the turn happened, ISO.
+     *
+     * Carried for the SAVED transcript rather than for the on-screen one: a file
+     * that outlives the session is read later, when "when did I ask that?" is the
+     * actual question, and a record without times answers it badly.
+     */
+    timestamp: string;
+    /**
+     * `undefined` on turns recorded before session ids existed.
+     *
+     * ★ REQUIRED-but-nullable rather than optional, and the difference is the
+     * whole point. With `sessionId?: string`, an object rebuilt without the key is
+     * still structurally assignable — so a refactor that mapped turns through and
+     * dropped it would compile, and every session would silently run back
+     * together. Written this way, omitting the key is a type error and passing
+     * `undefined` is a decision someone made on purpose.
+     */
+    sessionId: string | undefined;
+}
+export {};
+//# sourceMappingURL=turnVisibility.d.ts.map

package/dist/shared/assistant/voice/turnVisibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turnVisibility.d.ts","sourceRoot":"","sources":["../../../../src/shared/assistant/voice/turnVisibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,UAAU,QAAQ;IAChB,QAAQ,CAAC,EAAE,CAAC;QAAE,KAAK,CAAC,EAAE,OAAO,CAAC;QAAC,cAAc,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;CACjG;AAED,gEAAgE;AAChE,wBAAgB,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAEtD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAGtE;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG;IAAE,KAAK,CAAC,EAAE,IAAI,CAAC;IAAC,cAAc,CAAC,EAAE,MAAM,CAAA;CAAE,CAEpG;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAEzE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAE9E;AAED,yEAAyE;AACzE,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC;;;OAGG;IACH,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,CAAC,EAAE,CAAC;CACZ;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,EAAE,GAAG,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAE9F;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,GAC3C,iBAAiB,CAAC,CAAC,CAAC,EAAE,CAWxB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,GAAG,WAAW,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;OAMG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;;;;;;;OASG;IACH,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CAC/B"}

package/dist/shared/assistant/voice/turnVisibility.js

@@ -0,0 +1,36 @@
+//#region src/shared/assistant/voice/turnVisibility.ts
+function e(e) {
+	return e.metadata?.voice === !0;
+}
+function t(e) {
+	let t = e.metadata?.voiceSessionId;
+	return typeof t == "string" && t.length > 0 ? t : void 0;
+}
+function n(e) {
+	return e ? {
+		voice: !0,
+		voiceSessionId: e
+	} : {};
+}
+function r(t) {
+	return t.filter((t) => !e(t));
+}
+function i(t) {
+	return t.filter(e);
+}
+function a(e) {
+	return o(e, t);
+}
+function o(e, t) {
+	let n = [];
+	for (let r of e) {
+		let e = t(r), i = n[n.length - 1];
+		i && i.sessionId === e ? i.turns.push(r) : n.push({
+			sessionId: e,
+			turns: [r]
+		});
+	}
+	return n;
+}
+//#endregion
+export { r as chatTurns, a as groupBySession, o as groupConsecutiveBySession, e as isVoiceTurn, n as voiceMarker, t as voiceSessionIdOf, i as voiceTurnsOnly };

package/dist/shared-assistant.js

@@ -4,4 +4,5 @@ import { AssistantRuntimeManager as _ } from "./shared/assistant/runtime.js";
 import { buildProgress as v, getAssistantMedia as y, isRecoverable as b, mapSessionToHistory as x, mergeMessagesById as S, sanitize as C } from "./shared/assistant/progress.js";
 import { createSandboxAssistantTransport as w } from "./shared/assistant/createSandboxAssistantTransport.js";
 import { useSandboxAssistantTransport as T } from "./shared/assistant/useSandboxAssistantTransport.js";
-export { _ as AssistantRuntimeManager, v as buildProgress, t as buildPromptRequestBody, n as checkAssistantAiCredits, r as createAssistantSandbox, i as createAssistantSession, w as createSandboxAssistantTransport, a as downloadAssistantArtifact, o as extendAssistantSandboxTTL, s as findExistingSandbox, c as getAssistantArtifacts, y as getAssistantMedia, l as getAssistantMessages, u as getAssistantSession, d as getAssistantStreamAccess, e as isQuotaExhaustedError, b as isRecoverable, x as mapSessionToHistory, S as mergeMessagesById, f as reportAssistantAiTokenUsage, C as sanitize, p as sendAssistantPromptAsync, m as sendHeartbeat, T as useSandboxAssistantTransport, h as waitForAssistantServiceReady, g as waitForSandboxRunning };
+import { chatTurns as E, groupBySession as D, groupConsecutiveBySession as O, isVoiceTurn as k, voiceMarker as A, voiceSessionIdOf as j, voiceTurnsOnly as M } from "./shared/assistant/voice/turnVisibility.js";
+export { _ as AssistantRuntimeManager, v as buildProgress, t as buildPromptRequestBody, E as chatTurns, n as checkAssistantAiCredits, r as createAssistantSandbox, i as createAssistantSession, w as createSandboxAssistantTransport, a as downloadAssistantArtifact, o as extendAssistantSandboxTTL, s as findExistingSandbox, c as getAssistantArtifacts, y as getAssistantMedia, l as getAssistantMessages, u as getAssistantSession, d as getAssistantStreamAccess, D as groupBySession, O as groupConsecutiveBySession, e as isQuotaExhaustedError, b as isRecoverable, k as isVoiceTurn, x as mapSessionToHistory, S as mergeMessagesById, f as reportAssistantAiTokenUsage, C as sanitize, p as sendAssistantPromptAsync, m as sendHeartbeat, T as useSandboxAssistantTransport, A as voiceMarker, j as voiceSessionIdOf, M as voiceTurnsOnly, h as waitForAssistantServiceReady, g as waitForSandboxRunning };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/fe-libs",
-  "version": "2026.825.7",
+  "version": "2026.903.1",
   "description": "Burdenoff frontend primitives and domain libraries",
   "type": "module",
   "bin": {
@@ -220,8 +220,14 @@
       "import": "./dist/shared/shims/*.js",
       "default": "./dist/shared/shims/*.js"
     },
-    "./shared/styles/app-shell.css": "./src/shared/styles/app-shell.css",
-    "./shared/styles/native.css": "./src/shared/styles/native.css",
+    "./shared/styles/app-shell.css": {
+      "style": "./src/shared/styles/app-shell.css",
+      "default": "./src/shared/styles/app-shell.css"
+    },
+    "./shared/styles/native.css": {
+      "style": "./src/shared/styles/native.css",
+      "default": "./src/shared/styles/native.css"
+    },
     "./shared/utils/lazyWithRetry": {
       "types": "./dist/shared/utils/lazyWithRetry.d.ts",
       "import": "./dist/shared/utils/lazyWithRetry.js"
@@ -296,6 +302,7 @@
     "lint:sanity": "if [ \"${CI:-}\" = \"true\" ]; then bun run lint; else bun run lint -- --cache --cache-location .eslintcache; fi",
     "format": "prettier --config shared/config/prettier.config.mjs --write \"src/**/*.{ts,tsx}\" \"!src/config/*.config.ts\"",
     "type:check": "bash scripts/build-limits.sh tsc --noEmit",
+    "test:package-css-exports": "node scripts/validate-package-css-exports.mjs",
     "test": "bun test scripts/graphql-schema-drift/__tests__ scripts/a11y-audit/__tests__ src/credentials src/storage src/shared/assistant src/shared/graphql/links/sse-link.test.ts src/shared/providers/AppShellProvider.test.ts src/shared/events/sinks/RybbitSink.test.ts src/shell-native src/shared/native src/chrome/__tests__ src/ui/__tests__",
     "sanity": "bash scripts/build-limits.sh --gate bash -c 'bun run lint:sanity && bun run format && bun run type:check && bun run test && bun run build'",
     "switch:status": "bun scripts/deps-mode.ts status",