@burdenoff/fe-libs 2026.1007.6 → 2026.1008.2

package/dist/shared/assistant/useAssistantAttachments.js

@@ -1,245 +1,189 @@
-import { graphqlFetch as e } from "../graphql/fetch.js";
-import "../../shared-graphql.js";
-import { downscaleImage as t } from "../utils/imageDownscale.js";
-import { useAssistantStorageFolders as n } from "./product.js";
-import { useAssistantTr as r } from "./i18n.js";
-import { AttachmentRejectedError as i, INLINE_IMAGE_QUALITY as a, classifyAttachment as o, detectDocumentFormat as s, getAttachmentSendBlocker as c, resolveAssistantInlineLimits as l, truncateForInline as u, validateFile as d } from "./attachments.js";
-import { getWorkspaceId as f } from "./context.js";
-import { useSaveToFiles as p } from "../../storage/useSaveToFiles.js";
-import "../../storage/index.js";
-import { extractDocumentText as m } from "./documentExtract.js";
-import { useCallback as h, useEffect as g, useRef as _, useState as v } from "react";
+import { downscaleImage as e } from "../utils/imageDownscale.js";
+import { AttachmentRejectedError as t, INLINE_IMAGE_QUALITY as n, classifyAttachment as r, detectDocumentFormat as i, getAttachmentSendBlocker as a, resolveAssistantInlineLimits as o, truncateForInline as s, validateFile as c } from "./attachments.js";
+import "./attachmentCommit.js";
+import { useAttachmentCommitter as l } from "./useAttachmentCommitter.js";
+import { extractDocumentText as u } from "./documentExtract.js";
+import { useCallback as d, useEffect as f, useRef as p, useState as m } from "react";
 //#region src/shared/assistant/useAssistantAttachments.ts
-var y = "\n  query AssistantAttachmentUrl($id: ID!) {\n    getFileDownloadUrl(id: $id)\n  }\n";
-async function b(t, n) {
-	if (!t || !n) return null;
-	try {
-		return (await e({
-			gateway: "workspace",
-			query: y,
-			variables: { id: t },
-			workspaceToken: !0,
-			workspaceId: n,
-			suppressGlobalErrorEvent: !0
-		})).data?.getFileDownloadUrl ?? null;
-	} catch {
-		return null;
-	}
-}
-var x = 0;
-function S() {
-	return x += 1, `att-${Date.now()}-${x}`;
+var h = 0;
+function g() {
+	return h += 1, `att-${Date.now()}-${h}`;
 }
-async function C(e, n) {
-	let r = o(e.type, e.name), c = {
-		id: S(),
+async function _(a, o) {
+	let c = r(a.type, a.name), l = {
+		id: g(),
 		status: "pending"
 	};
-	if (r === "image") {
-		let n = await t(e, {
+	if (c === "image") {
+		let r = await e(a, {
 			encodeFallback: !1,
 			inline: {
 				maxDim: 768,
-				quality: a
+				quality: n
 			}
 		});
-		if (!n.downscaled && n.blob.size > 10485760) throw new i("unsupported-image");
-		return {
+		if (!r.downscaled && r.blob.size > 10485760) throw new t("unsupported-image");
+		return v({
 			attachment: {
-				...c,
-				filename: n.filename,
-				mimeType: n.mimeType,
-				size: n.blob.size,
-				kind: r,
-				previewUrl: n.dataUrl || void 0,
-				inlineDataUrl: n.inlineDataUrl
+				...l,
+				filename: r.filename,
+				mimeType: r.mimeType,
+				size: r.blob.size,
+				kind: c,
+				previewUrl: r.dataUrl || void 0,
+				inlineDataUrl: r.inlineDataUrl
 			},
-			blob: n.blob
-		};
+			blob: r.blob
+		});
 	}
-	if (r === "text") {
-		let { text: t, truncated: i } = u(await e.text(), n);
-		return {
+	let d = new Blob([await a.arrayBuffer()], { type: a.type || "application/octet-stream" });
+	if (c === "text") {
+		let { text: e, truncated: t } = s(await d.text(), o);
+		return v({
 			attachment: {
-				...c,
-				filename: e.name,
-				mimeType: e.type || "text/plain",
-				size: e.size,
-				kind: r,
-				textContent: t,
-				textTruncated: i
+				...l,
+				filename: a.name,
+				mimeType: a.type || "text/plain",
+				size: a.size,
+				kind: c,
+				textContent: e,
+				textTruncated: t
 			},
-			blob: e
-		};
+			blob: d
+		});
 	}
-	let l = s(e.type, e.name);
-	if (l) {
-		let t = await m(e, l, n);
-		return {
+	let f = i(a.type, a.name);
+	if (f) {
+		let e = await u(new File([d], a.name, { type: d.type }), f, o);
+		return v({
 			attachment: {
-				...c,
-				filename: e.name,
-				mimeType: e.type || "application/octet-stream",
-				size: e.size,
-				kind: r,
-				extraction: t.extraction,
-				textContent: t.textContent,
-				textTruncated: t.textTruncated,
-				documentPages: t.documentPages
+				...l,
+				filename: a.name,
+				mimeType: a.type || "application/octet-stream",
+				size: a.size,
+				kind: c,
+				extraction: e.extraction,
+				textContent: e.textContent,
+				textTruncated: e.textTruncated,
+				documentPages: e.documentPages
 			},
-			blob: e
-		};
+			blob: d
+		});
 	}
-	return {
+	return v({
 		attachment: {
-			...c,
-			filename: e.name,
-			mimeType: e.type || "application/octet-stream",
-			size: e.size,
-			kind: r
+			...l,
+			filename: a.name,
+			mimeType: a.type || "application/octet-stream",
+			size: a.size,
+			kind: c
 		},
-		blob: e
+		blob: d
+	});
+}
+function v(e) {
+	if (e.blob.size <= 5242880) return e;
+	let { attachment: n } = e;
+	if (n.kind === "image" || !n.textContent) throw new t("too-large-to-save");
+	return {
+		...e,
+		attachment: {
+			...n,
+			inlineOnly: !0
+		}
 	};
 }
-function w(e = {}) {
-	let t = r(), a = l({ maxInlineCharsPerFile: e.perFileChars }).perFileChars, o = n(), { save: s } = p(), [u, m] = v([]), [y, x] = v(null), S = _(Promise.resolve()), [w, T] = v(0), E = _(0), D = _(/* @__PURE__ */ new Map()), O = _(/* @__PURE__ */ new Set()), k = _(0), A = _(!0);
-	g(() => () => {
-		A.current = !1;
-	}, []);
-	let j = _([]);
-	g(() => {
-		j.current = u;
-	}, [u]);
-	let M = h((e, t) => {
-		A.current && m((n) => n.map((n) => n.id === e ? {
+function y(e = {}) {
+	let n = o({ maxInlineCharsPerFile: e.perFileChars }).perFileChars, [r, i] = m([]), [s, u] = m(null), [h, g] = m(!1), v = p(Promise.resolve()), [y, b] = m(0), x = p(0), S = p(/* @__PURE__ */ new Map()), C = p(0), w = p(!0), T = p(r);
+	T.current = r;
+	let E = d((e, t) => {
+		w.current && i((n) => n.map((n) => n.id === e ? {
 			...n,
 			...t
 		} : n));
-	}, []), N = h(async ({ attachment: e, blob: n }) => {
-		if (!O.current.has(e.id)) {
-			M(e.id, {
-				status: "uploading",
-				progressNote: void 0
-			});
-			try {
-				let r = await s({
-					source: {
-						kind: "blob",
-						filename: e.filename,
-						mimeType: e.mimeType,
-						getBlob: async () => ({
-							blob: n,
-							filename: e.filename,
-							mimeType: e.mimeType
-						})
-					},
-					folderPath: o.attachments,
-					onRetry: (n) => {
-						O.current.has(e.id) || M(e.id, { progressNote: n.kind === "cold-start" ? t("attachments.waking", "File service is starting up — retry {{attempt}} of {{max}}", {
-							attempt: String(n.attempt),
-							max: String(n.maxAttempts)
-						}) : t("attachments.retrying", "Retrying {{attempt}} of {{max}}", {
-							attempt: String(n.attempt),
-							max: String(n.maxAttempts)
-						}) });
-					}
-				});
-				if (O.current.has(e.id)) return;
-				let i = r?.id ? await b(r.id, f()) : null;
-				if (O.current.has(e.id)) return;
-				M(e.id, {
-					status: "ready",
-					fileId: r?.id,
-					downloadUrl: i ?? void 0,
-					progressNote: void 0
-				});
-			} catch (t) {
-				if (O.current.has(e.id)) return;
-				if (e.kind === "text" || e.textContent) {
-					M(e.id, {
-						status: "ready",
-						progressNote: void 0
-					});
-					return;
-				}
-				M(e.id, {
-					status: "error",
-					error: t instanceof Error ? t.message : "Upload failed",
-					progressNote: void 0
-				});
-			}
-		}
-	}, [
-		M,
-		s,
-		t
-	]), P = h((e) => {
-		if (!e) return;
-		let t = Array.from(e);
-		if (t.length === 0) return;
-		x(null);
-		let n = [];
-		for (let e of t) {
-			let t = d(e, k.current);
+	}, []), D = l(E), O = p(D);
+	O.current = D, f(() => (w.current = !0, () => {
+		w.current = !1, O.current.cancel(), O.current.discardPending();
+	}), []);
+	let k = d((e) => {
+		if (!e || O.current.isCommitting) return;
+		let r = Array.from(e);
+		if (r.length === 0) return;
+		u(null);
+		let a = [];
+		for (let e of r) {
+			let t = c(e, C.current);
 			if (t) {
-				x(t);
+				u(t);
 				continue;
 			}
-			n.push(e), k.current += 1;
+			a.push(e), C.current += 1;
 		}
-		if (n.length !== 0) {
-			T((e) => e + n.length);
-			for (let e of n) {
-				let t = E.current;
-				S.current = S.current.then(async () => {
-					let n = null;
+		if (a.length !== 0) {
+			b((e) => e + a.length);
+			for (let e of a) {
+				let r = x.current;
+				v.current = v.current.then(async () => {
+					let a = null;
 					try {
-						n = await C(e, a);
+						a = await _(e, n);
 					} catch (e) {
-						k.current = Math.max(0, k.current - 1), A.current && x(e instanceof i ? e.reason : "unreadable");
+						C.current = Math.max(0, C.current - 1), w.current && u(e instanceof t ? e.reason : "unreadable");
 					}
-					if (!A.current || (T((e) => Math.max(0, e - 1)), !n)) return;
-					if (t !== E.current) {
-						k.current = Math.max(0, k.current - 1);
+					if (!w.current || (b((e) => Math.max(0, e - 1)), !a)) return;
+					if (r !== x.current) {
+						C.current = Math.max(0, C.current - 1);
 						return;
 					}
-					let r = n;
-					D.current.set(r.attachment.id, r.blob), m((e) => [...e, r.attachment]), await N(r);
+					let o = a;
+					S.current.set(o.attachment.id, o.blob), i((e) => [...e, {
+						...o.attachment,
+						status: "ready"
+					}]);
 				});
 			}
 		}
-	}, [N, a]), F = h((e) => {
-		O.current.add(e), D.current.delete(e), k.current = Math.max(0, k.current - 1), m((t) => t.filter((t) => t.id !== e));
-	}, []), I = h((e) => {
-		let t = j.current.find((t) => t.id === e), n = D.current.get(e);
-		!t || t.status !== "error" || !n || (O.current.delete(e), M(e, {
-			status: "pending",
+	}, [n]), A = d((e) => {
+		T.current.find((t) => t.id === e)?.status !== "uploading" && (S.current.delete(e), C.current = Math.max(0, C.current - 1), i((t) => t.filter((t) => t.id !== e)));
+	}, []), j = d((e) => {
+		let t = T.current.find((t) => t.id === e);
+		!t || !S.current.has(e) || t.status === "uploading" || t.status === "pending" || E(e, {
+			status: "ready",
 			error: void 0,
+			saveError: void 0,
+			progress: void 0,
 			progressNote: void 0
-		}), S.current = S.current.then(() => N({
-			attachment: {
-				...t,
-				status: "pending",
-				error: void 0
-			},
-			blob: n
-		})));
-	}, [M, N]), L = h(() => {
-		E.current += 1, k.current = 0, j.current.forEach((e) => O.current.add(e.id)), D.current.clear(), m([]);
-	}, []), R = c(w, u);
+		});
+	}, [E]), M = d(() => O.current.cancel(), []), N = d(async (e) => {
+		let t = T.current.filter((e) => e.status === "ready").map((e) => ({
+			attachment: e,
+			blob: S.current.get(e.id) ?? null
+		}));
+		g(!0);
+		try {
+			return await O.current.commit(t, e);
+		} finally {
+			w.current && g(!1);
+		}
+	}, []), P = d(() => {
+		O.current.cancel(), O.current.discardPending(), x.current += 1, C.current = 0, S.current.clear(), i([]);
+	}, []), F = d(() => u(null), []), I = a(y, r);
 	return {
-		attachments: u,
-		isBusy: R === "in-flight",
-		preparingCount: w,
-		sendBlocker: R,
-		rejection: y,
-		addFiles: P,
-		remove: F,
-		retry: I,
-		clear: L,
-		clearRejection: h(() => x(null), []),
-		canAddMore: k.current < 5
+		attachments: r,
+		isBusy: I === "in-flight",
+		preparingCount: y,
+		sendBlocker: I,
+		rejection: s,
+		addFiles: k,
+		remove: A,
+		retry: j,
+		clear: P,
+		clearRejection: F,
+		canAddMore: C.current < 5,
+		commit: N,
+		cancelCommit: M,
+		isCommitting: h
 	};
 }
 //#endregion
-export { w as useAssistantAttachments };
+export { y as useAssistantAttachments };

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

@@ -0,0 +1,17 @@
+import { FilesPort } from '../../storage/filesPort';
+import { AttachmentCommitter, CommitOptions } from './attachmentCommit';
+/**
+ * A test seam: a `FilesPort` that replaces the Apollo-backed one for everything below it. Never
+ * provided in production.
+ */
+export declare const AttachmentFilesPortContext: import('react').Context<FilesPort | null>;
+/** The Files port for this tree: the override if one is provided, else the Apollo client's. */
+export declare function useAttachmentFilesPort(): FilesPort | null;
+/** Mint a download URL for a saved file (Retry replays an old turn's attachments). */
+export declare function useAttachmentUrlResolver(): (fileId: string) => Promise<string | null>;
+/**
+ * One committer per mounted draft. `onChange` and the product's folder are read at call time, so
+ * the committer (and the failed rollbacks it remembers) survives re-renders.
+ */
+export declare function useAttachmentCommitter(onChange: NonNullable<CommitOptions['onChange']>): AttachmentCommitter;
+//# sourceMappingURL=useAttachmentCommitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useAttachmentCommitter.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/useAttachmentCommitter.ts"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,SAAS,EAEf,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,aAAa,EACnB,MAAM,oBAAoB,CAAC;AAG5B;;;GAGG;AACH,eAAO,MAAM,0BAA0B,2CAAwC,CAAC;AAEhF,+FAA+F;AAC/F,wBAAgB,sBAAsB,IAAI,SAAS,GAAG,IAAI,CAOzD;AAED,sFAAsF;AACtF,wBAAgB,wBAAwB,IAAI,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAGrF;AAkBD;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,WAAW,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,GAC/C,mBAAmB,CAqBrB"}

package/dist/shared/assistant/useAttachmentCommitter.js

@@ -0,0 +1,41 @@
+import { useAssistantStorageFolders as e } from "./product.js";
+import { FilesPortError as t, createApolloFilesPort as n } from "../../storage/filesPort.js";
+import { createAttachmentCommitter as r } from "./attachmentCommit.js";
+import { getWorkspaceId as i } from "./context.js";
+import { createContext as a, useCallback as o, useContext as s, useMemo as c, useRef as l } from "react";
+import { getApolloContext as u } from "@apollo/client/react";
+//#region src/shared/assistant/useAttachmentCommitter.ts
+var d = a(null);
+function f() {
+	let e = s(d), { client: t } = s(u());
+	return c(() => e ?? (t ? n(t, { getWorkspaceId: i }) : null), [e, t]);
+}
+function p() {
+	let e = f();
+	return o(async (t) => e ? e.getDownloadUrl(t) : null, [e]);
+}
+var m = (e) => () => Promise.reject(new t(e, "File storage is not available here.", void 0)), h = {
+	ensureFolder: m("ensureFolder"),
+	initiate: m("initiate"),
+	put: m("put"),
+	complete: m("complete"),
+	getSession: m("getSession"),
+	listSessions: m("listSessions"),
+	abort: m("abort"),
+	getDownloadUrl: m("getDownloadUrl"),
+	deleteFile: m("deleteFile")
+};
+function g(t) {
+	let n = f(), i = e(), a = l(t);
+	a.current = t;
+	let o = l(i.attachments);
+	return o.current = i.attachments, c(() => r({
+		port: n ?? h,
+		get folderPath() {
+			return o.current;
+		},
+		onChange: (e, t) => a.current(e, t)
+	}), [n]);
+}
+//#endregion
+export { d as AttachmentFilesPortContext, g as useAttachmentCommitter, f as useAttachmentFilesPort, p as useAttachmentUrlResolver };

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

@@ -0,0 +1,36 @@
+import { AssistantAttachment } from './attachments';
+import { AttachmentCommitFailure, AttachmentCommitResult, CommitOptions } from './attachmentCommit';
+/** How long a spoken turn waits for its files to be saved before it drops them. */
+export declare const VOICE_COMMIT_BUDGET_MS = 20000;
+/** The slice of the attachment draft this needs; `useAssistantAttachments` provides it. */
+export interface SpokenTurnDraft {
+    readonly attachments: readonly AssistantAttachment[];
+    commit: (options?: {
+        mode?: CommitOptions['mode'];
+        budgetMs?: number;
+        signal?: AbortSignal;
+    }) => Promise<AttachmentCommitResult>;
+    clear: () => void;
+}
+export interface SettleSpokenTurnDeps {
+    draft: SpokenTurnDraft;
+    /** `maySendSpokenTurn` for this turn: false once the session ended or the conversation went. */
+    maySend: () => boolean;
+    /** Hand the turn over. Called after the commit, with only the attachments that may travel. */
+    sendTurn: (attachments: AssistantAttachment[]) => void;
+    /** Some files could not be saved and were not sent. Called once, before `sendTurn`. */
+    announceDropped: (count: number, failures: readonly AttachmentCommitFailure[]) => void;
+    budgetMs?: number;
+}
+export type SpokenTurnOutcome = 
+/** The turn was sent (possibly without some files). */
+{
+    kind: 'sent';
+    dropped: number;
+}
+/** The turn no longer belongs anywhere; nothing was sent and the draft is cleared. */
+ | {
+    kind: 'abandoned';
+};
+export declare function settleAndCommitSpokenTurn(deps: SettleSpokenTurnDeps): Promise<SpokenTurnOutcome>;
+//# sourceMappingURL=voiceCommit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"voiceCommit.d.ts","sourceRoot":"","sources":["../../../src/shared/assistant/voiceCommit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAA0B,KAAK,mBAAmB,EAAE,MAAM,eAAe,CAAC;AACjF,OAAO,KAAK,EACV,uBAAuB,EACvB,sBAAsB,EACtB,aAAa,EACd,MAAM,oBAAoB,CAAC;AAE5B,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,QAAS,CAAC;AAE7C,2FAA2F;AAC3F,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,WAAW,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACrD,MAAM,EAAE,CAAC,OAAO,CAAC,EAAE;QACjB,IAAI,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;QAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;IACtC,KAAK,EAAE,MAAM,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,eAAe,CAAC;IACvB,gGAAgG;IAChG,OAAO,EAAE,MAAM,OAAO,CAAC;IACvB,8FAA8F;IAC9F,QAAQ,EAAE,CAAC,WAAW,EAAE,mBAAmB,EAAE,KAAK,IAAI,CAAC;IACvD,uFAAuF;IACvF,eAAe,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,uBAAuB,EAAE,KAAK,IAAI,CAAC;IACvF,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,MAAM,iBAAiB;AAC3B,uDAAuD;AACrD;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE;AACnC,sFAAsF;GACpF;IAAE,IAAI,EAAE,WAAW,CAAA;CAAE,CAAC;AAQ1B,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,oBAAoB,GACzB,OAAO,CAAC,iBAAiB,CAAC,CAyC5B"}

package/dist/shared/assistant/voiceCommit.js

@@ -0,0 +1,24 @@
+import { getSendableAttachments as e } from "./attachments.js";
+//#region src/shared/assistant/voiceCommit.ts
+var t = 2e4;
+function n(e) {
+	return e.some((e) => e.status === "ready" && !e.fileId && !e.inlineOnly);
+}
+async function r(t) {
+	let { draft: r } = t;
+	if (!t.maySend()) return r.clear(), { kind: "abandoned" };
+	if (!n(r.attachments)) return t.sendTurn(e([...r.attachments])), r.clear(), {
+		kind: "sent",
+		dropped: 0
+	};
+	let i = await r.commit({
+		mode: "best-effort",
+		budgetMs: t.budgetMs ?? 2e4
+	});
+	return i.ok ? t.maySend() ? (i.dropped.length > 0 && t.announceDropped(i.dropped.length, i.dropped), t.sendTurn(e(i.attachments)), i.handedOver(), r.clear(), {
+		kind: "sent",
+		dropped: i.dropped.length
+	}) : (await i.rollback(), r.clear(), { kind: "abandoned" }) : (r.clear(), { kind: "abandoned" });
+}
+//#endregion
+export { t as VOICE_COMMIT_BUDGET_MS, r as settleAndCommitSpokenTurn };