@burdenoff/fe-libs 2026.813.1 → 2026.813.3

package/dist/storage/retryPolicy.js

@@ -0,0 +1,150 @@
+//#region src/storage/retryPolicy.ts
+var e = 3, t = [1e4, 2e4], n = 75e3, r = [400, 800], i = new Set([
+	"OPERATION_TIMEOUT",
+	"GATEWAY_TIMEOUT",
+	"REQUEST_TIMEOUT",
+	"TIMEOUT"
+]), a = new Set([
+	"QUOTA_NOT_PROVISIONED",
+	"QUOTA_EXHAUSTED",
+	"QUOTA_EXCEEDED",
+	"FORBIDDEN",
+	"UNAUTHENTICATED",
+	"UNAUTHORIZED",
+	"BAD_USER_INPUT",
+	"BAD_REQUEST",
+	"GRAPHQL_VALIDATION_FAILED",
+	"GRAPHQL_PARSE_FAILED",
+	"PERSISTED_QUERY_NOT_FOUND",
+	"NOT_FOUND",
+	"CONFLICT",
+	"PAYLOAD_TOO_LARGE"
+]), o = new Set([
+	408,
+	504,
+	524
+]), s = /\boperation\s+timed?\s?out\b/i;
+function c(e) {
+	return !e || typeof e != "object" ? null : e;
+}
+function l(e) {
+	let t = c(e);
+	if (!t) return [];
+	let n = [], r = (e) => {
+		typeof e == "string" && e.length > 0 && n.push(e);
+	};
+	r(t.extensions?.code);
+	for (let e of t.errors ?? t.graphQLErrors ?? []) r(e?.extensions?.code);
+	let i = c(t.networkError);
+	if (i) {
+		r(i.extensions?.code);
+		for (let e of i.errors ?? i.graphQLErrors ?? []) r(e?.extensions?.code);
+	}
+	return n;
+}
+function u(e) {
+	let t = [], n = (e) => {
+		typeof e == "number" && Number.isFinite(e) && t.push(e);
+	}, r = c(e);
+	if (!r) return t;
+	n(r.statusCode), n(r.status);
+	let i = c(r.networkError);
+	return i && (n(i.statusCode), n(i.status)), t;
+}
+function d(e) {
+	let t = c(e);
+	if (!t) return [];
+	let n = [], r = (e) => {
+		typeof e == "string" && e.length > 0 && n.push(e);
+	};
+	r(t.message);
+	for (let e of t.errors ?? t.graphQLErrors ?? []) r(e?.message);
+	return n;
+}
+function f(e) {
+	if (!e || typeof e != "object") return;
+	let t = e, n = (t.errors ?? t.graphQLErrors)?.[0]?.message;
+	if (typeof n == "string" && n.length > 0) return n;
+	if (typeof t.message == "string" && t.message.length > 0) return t.message;
+}
+function p(e) {
+	if (!e || typeof e != "object") return null;
+	let t = l(e), n = u(e);
+	return t.some((e) => a.has(e)) || n.some((e) => e >= 400 && e < 500 && e !== 408) ? null : t.some((e) => i.has(e)) || n.some((e) => o.has(e)) || d(e).some((e) => s.test(e)) ? "cold-start" : c(e)?.networkError || t.includes("INTERNAL_SERVER_ERROR") ? "transient-blip" : null;
+}
+var m = {
+	"cold-start": 3,
+	"transient-blip": 3
+}, h = {
+	"cold-start": t,
+	"transient-blip": r
+}, g = ["cold-start"];
+function _(e, t) {
+	let n = p(e);
+	if (!n) return {
+		retry: !1,
+		reason: "not-retryable"
+	};
+	if (!(t.allow ?? g).includes(n)) return {
+		retry: !1,
+		reason: "kind-not-allowed"
+	};
+	let r = m[n];
+	if (t.attempt >= r) return {
+		retry: !1,
+		reason: "attempts-exhausted"
+	};
+	let i = h[n], a = i[Math.min(t.attempt - 1, i.length - 1)] ?? 0;
+	return n === "cold-start" && t.elapsedMs + a >= 75e3 ? {
+		retry: !1,
+		reason: "budget-exhausted"
+	} : {
+		retry: !0,
+		kind: n,
+		delayMs: a,
+		nextAttempt: t.attempt + 1,
+		maxAttempts: r
+	};
+}
+var v = (e) => new Promise((t) => setTimeout(t, e));
+async function y(e, t = {}) {
+	let n = t.now ?? (() => Date.now()), r = t.sleep ?? v, i = n(), a = 0;
+	for (;;) {
+		a += 1;
+		let o, s, c = !1;
+		try {
+			o = await e(a);
+		} catch (e) {
+			c = !0, s = e, o = {
+				ok: !1,
+				error: e
+			};
+		}
+		if (o.ok) return {
+			value: o.value,
+			attempts: a
+		};
+		let l = _(o.error, {
+			attempt: a,
+			elapsedMs: n() - i,
+			...t.allow ? { allow: t.allow } : {}
+		});
+		if (!l.retry) {
+			if (c) throw s;
+			return {
+				error: o.error,
+				attempts: a,
+				gaveUpBecause: l.reason
+			};
+		}
+		t.onRetry?.({
+			kind: l.kind,
+			attempt: l.nextAttempt,
+			maxAttempts: l.maxAttempts,
+			delayMs: l.delayMs,
+			error: o.error
+		}), await r(l.delayMs);
+	}
+}
+//#endregion
+export { e as COLD_START_MAX_ATTEMPTS, n as COLD_START_RETRY_BUDGET_MS, t as COLD_START_RETRY_DELAYS_MS, p as classifyFilesError, _ as decideFilesRetry, f as extractErrorMessage, y as runWithFilesRetry };

package/dist/storage/uploadBlob.d.ts

@@ -1,9 +1,17 @@
 import { ApolloClient } from '@apollo/client';
+import { extractErrorMessage, FilesRetryNotice } from './retryPolicy';
+export { extractErrorMessage };
 /**
  * Apollo invalidations every "Save to Files" caller benefits from — pulled
  * from microfe-files' useUploadFile to keep the browse views in sync.
  */
 export declare const FILES_AFTER_SAVE_REFETCH: string[];
+/** Which gateway hop a retry notice is about, so the UI can name it. */
+export type SaveToFilesStep = 'folder' | 'initiate' | 'complete';
+/** A retry notice with the step attached. */
+export interface SaveToFilesRetryNotice extends FilesRetryNotice {
+    step: SaveToFilesStep;
+}
 export interface UploadBlobParams {
     client: ApolloClient;
     blob: Blob;
@@ -11,22 +19,23 @@ export interface UploadBlobParams {
     mimeType: string;
     folderId: string;
     onProgress?: (pct: number) => void;
+    /**
+     * Fired before each retry wait. The upload is still running — this exists so the UI
+     * can explain a 60-second pause instead of looking frozen. It is never a failure
+     * signal; a genuine failure still arrives as a rejection.
+     */
+    onRetry?: (notice: SaveToFilesRetryNotice) => void;
+    /**
+     * Test seam for the retry ladder's clock and waits. Production callers never set
+     * these — without them the real ladder (tens of seconds) runs, which is the point.
+     */
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
 }
 export interface UploadedFile {
     id: string;
     name: string;
     folderId: string | null;
 }
-/**
- * Best-effort message extraction, preferring the first GraphQL error's message
- * (Apollo v4 CombinedGraphQLErrors `.errors`, or v3 `.graphQLErrors`) so we surface
- * the real reason a completeUpload failed instead of a generic error envelope.
- *
- * Exported because every `client.mutate` call in this module faces the same
- * problem: under `errorPolicy: 'all'` the failure arrives in-band on
- * `result.error` and the caller's own "that didn't work" string is the LEAST
- * informative thing it could report. See `useSaveToFiles`.
- */
-export declare function extractErrorMessage(err: unknown): string | undefined;
 export declare function uploadBlobToFiles(params: UploadBlobParams): Promise<UploadedFile>;
 //# sourceMappingURL=uploadBlob.d.ts.map

package/dist/storage/uploadBlob.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uploadBlob.d.ts","sourceRoot":"","sources":["../../src/storage/uploadBlob.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAyBxD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,UAKpC,CAAC;AAEF,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACpC;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AA2BD;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAWpE;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CA8HvF"}
+{"version":3,"file":"uploadBlob.d.ts","sourceRoot":"","sources":["../../src/storage/uploadBlob.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAExD,OAAO,EAAE,mBAAmB,EAAqB,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAE9F,OAAO,EAAE,mBAAmB,EAAE,CAAC;AAyB/B;;;GAGG;AACH,eAAO,MAAM,wBAAwB,UAKpC,CAAC;AAEF,wEAAwE;AACxE,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAEjE,6CAA6C;AAC7C,MAAM,WAAW,sBAAuB,SAAQ,gBAAgB;IAC9D,IAAI,EAAE,eAAe,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,YAAY,CAAC;IACrB,IAAI,EAAE,IAAI,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,sBAAsB,KAAK,IAAI,CAAC;IACnD;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,wBAAsB,iBAAiB,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,YAAY,CAAC,CAuIvF"}

package/dist/storage/uploadBlob.js

@@ -1,6 +1,7 @@
-import { gql as e } from "@apollo/client";
+import { extractErrorMessage as e, runWithFilesRetry as t } from "./retryPolicy.js";
+import { gql as n } from "@apollo/client";
 //#region src/storage/uploadBlob.ts
-var t = e`
+var r = n`
   mutation SaveToFiles_InitiateUpload($input: InitiateUploadInput!) {
     initiateUpload(input: $input) {
       session {
@@ -9,7 +10,7 @@ var t = e`
       uploadUrl
     }
   }
-`, n = e`
+`, i = n`
   mutation SaveToFiles_CompleteUpload($input: CompleteUploadInput!) {
     completeUpload(input: $input) {
       file {
@@ -19,37 +20,48 @@ var t = e`
       }
     }
   }
-`, r = [
+`, a = [
 	"GetFilesRootBrowsePage",
 	"GetFilesFolderBrowsePage",
 	"GetFilesRecentPage",
 	"GetFiles"
 ];
-function i(e) {
-	if (!e || typeof e != "object") return !1;
-	let t = e;
-	return t.networkError ? !0 : (t.errors ?? t.graphQLErrors ?? []).some((e) => e?.extensions?.code === "INTERNAL_SERVER_ERROR");
-}
-function a(e) {
-	if (!e || typeof e != "object") return;
-	let t = e, n = (t.errors ?? t.graphQLErrors)?.[0]?.message;
-	if (typeof n == "string" && n.length > 0) return n;
-	if (typeof t.message == "string" && t.message.length > 0) return t.message;
-}
-async function o(e) {
-	let { client: o, blob: s, filename: c, mimeType: l, folderId: u, onProgress: d } = e, f = c.includes(".") ? c.substring(c.lastIndexOf(".") + 1) : "";
+async function o(n) {
+	let { client: o, blob: s, filename: c, mimeType: l, folderId: u, onProgress: d, onRetry: f } = n, p = c.includes(".") ? c.substring(c.lastIndexOf(".") + 1) : "", m = {
+		...n.now ? { now: n.now } : {},
+		...n.sleep ? { sleep: n.sleep } : {}
+	};
 	d?.(0);
-	let p = await o.mutate({
-		mutation: t,
-		variables: { input: {
-			fileName: c,
-			fileSize: String(s.size),
-			mimeType: l,
-			extension: f,
-			folderId: u
-		} }
-	}), m = p.data?.initiateUpload?.session, h = p.data?.initiateUpload?.uploadUrl;
-	if (!m || !h) throw Error(a(p.error) ?? "initiateUpload did not return a presigned URL");
+	let h = await t(async () => {
+		let e = await o.mutate({
+			mutation: r,
+			variables: { input: {
+				fileName: c,
+				fileSize: String(s.size),
+				mimeType: l,
+				extension: p,
+				folderId: u
+			} }
+		}), t = e.data?.initiateUpload?.session, n = e.data?.initiateUpload?.uploadUrl;
+		return t && n ? {
+			ok: !0,
+			value: {
+				session: t,
+				uploadUrl: n
+			}
+		} : {
+			ok: !1,
+			error: e.error
+		};
+	}, {
+		...m,
+		...f ? { onRetry: (e) => f({
+			...e,
+			step: "initiate"
+		}) } : {}
+	});
+	if (!h.value) throw Error(e(h.error) ?? "initiateUpload did not return a presigned URL");
+	let { session: g, uploadUrl: _ } = h.value;
 	d?.(10), await new Promise((e, t) => {
 		let n = new XMLHttpRequest();
 		n.upload.addEventListener("progress", (e) => {
@@ -59,44 +71,35 @@ async function o(e) {
 			}
 		}), n.addEventListener("load", () => {
 			n.status >= 200 && n.status < 300 ? (d?.(90), e()) : t(/* @__PURE__ */ Error(`Upload PUT failed with status ${n.status}`));
-		}), n.addEventListener("error", () => t(/* @__PURE__ */ Error("Upload PUT network error"))), n.addEventListener("abort", () => t(/* @__PURE__ */ Error("Upload PUT aborted"))), n.open("PUT", h), n.setRequestHeader("Content-Type", l), n.send(s);
+		}), n.addEventListener("error", () => t(/* @__PURE__ */ Error("Upload PUT network error"))), n.addEventListener("abort", () => t(/* @__PURE__ */ Error("Upload PUT aborted"))), n.open("PUT", _), n.setRequestHeader("Content-Type", l), n.send(s);
+	});
+	let v = await t(async () => {
+		let e = await o.mutate({
+			mutation: i,
+			variables: { input: {
+				sessionId: g.id,
+				fileSize: String(s.size),
+				folderId: u
+			} },
+			refetchQueries: a
+		}), t = e.data?.completeUpload?.file;
+		return t ? {
+			ok: !0,
+			value: t
+		} : {
+			ok: !1,
+			error: e.error
+		};
+	}, {
+		allow: ["cold-start", "transient-blip"],
+		...m,
+		...f ? { onRetry: (e) => f({
+			...e,
+			step: "complete"
+		}) } : {}
 	});
-	let g = async () => {
-		try {
-			let e = await o.mutate({
-				mutation: n,
-				variables: { input: {
-					sessionId: m.id,
-					fileSize: String(s.size),
-					folderId: u
-				} },
-				refetchQueries: r
-			}), t = e.data?.completeUpload?.file ?? void 0;
-			if (t) return { file: t };
-			let c = e.error;
-			return {
-				retryable: i(c),
-				message: a(c)
-			};
-		} catch (e) {
-			if (!i(e)) throw e;
-			return {
-				retryable: !0,
-				message: a(e)
-			};
-		}
-	}, _, v;
-	for (let e = 0; e <= 2; e++) {
-		e > 0 && await new Promise((t) => setTimeout(t, 400 * e));
-		let t = await g();
-		if (t.file) {
-			_ = t.file;
-			break;
-		}
-		if (v = t.message ?? v, !t.retryable) break;
-	}
-	if (!_) throw Error(v ?? "completeUpload did not return a file");
-	return d?.(100), _;
+	if (!v.value) throw Error(e(v.error) ?? "completeUpload did not return a file");
+	return d?.(100), v.value;
 }
 //#endregion
-export { r as FILES_AFTER_SAVE_REFETCH, a as extractErrorMessage, o as uploadBlobToFiles };
+export { a as FILES_AFTER_SAVE_REFETCH, o as uploadBlobToFiles };

package/dist/storage/useSaveToFiles.d.ts

@@ -1,5 +1,6 @@
 import { ApolloClient } from '@apollo/client';
 import { SaveToFilesSource } from './SaveToFilesButton';
+import { SaveToFilesRetryNotice } from './uploadBlob';
 export interface SavedFile {
     id: string;
     name: string;
@@ -9,13 +10,35 @@ export interface UseSaveToFilesResult {
     save: (params: {
         source: SaveToFilesSource;
         folderPath: string;
+        /**
+         * Fired before each retry wait. Purely informational — the save is still in
+         * flight. Exists so a caller rendering its own chip can say why a cold start is
+         * taking a minute instead of showing a spinner that looks stuck.
+         */
+        onRetry?: (notice: SaveToFilesRetryNotice) => void;
     }) => Promise<SavedFile>;
     isPending: boolean;
     error: Error | null;
     progress: number;
+    /**
+     * The retry currently being waited for or run — `{ step, attempt, maxAttempts,
+     * delayMs }`. Null on the first attempt of every step, and always cleared when the
+     * save settles either way, so it can never be mistaken for a result. Render it to
+     * explain a long pause; it is not an error and must not be shown as one.
+     */
+    retry: SaveToFilesRetryNotice | null;
 }
 /** The Apollo surface `resolveFolderIdByPath` needs — kept narrow so it is trivial to fake. */
 type FolderMutatingClient = Pick<ApolloClient, 'mutate'>;
+export interface ResolveFolderOptions {
+    onRetry?: (notice: SaveToFilesRetryNotice) => void;
+    /**
+     * Test seam for the retry ladder's clock and waits. Production callers never set
+     * these — without them the real ladder (tens of seconds) runs, which is the point.
+     */
+    now?: () => number;
+    sleep?: (ms: number) => Promise<void>;
+}
 /**
  * Resolve (creating if needed) the destination folder for a path, returning its id.
  *
@@ -38,8 +61,13 @@ type FolderMutatingClient = Pick<ApolloClient, 'mutate'>;
  * bad path or a missing folder and sent people looking at file-storage quota
  * they had plenty of. Surface the real reason; keep the path as a last resort
  * for the genuinely inexplicable case.
+ *
+ * A gateway timeout is now also *waited out* rather than only reported, because this
+ * is the hop that was measured failing on a cold container. Only a cold-start-class
+ * failure is retried — a quota rejection, an auth failure or any other 4xx answer
+ * still comes straight back, unchanged and immediately.
  */
-export declare function resolveFolderIdByPath(client: FolderMutatingClient, folderPath: string): Promise<string>;
+export declare function resolveFolderIdByPath(client: FolderMutatingClient, folderPath: string, options?: ResolveFolderOptions): Promise<string>;
 export declare function useSaveToFiles(): UseSaveToFilesResult;
 export {};
 //# sourceMappingURL=useSaveToFiles.d.ts.map

package/dist/storage/useSaveToFiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useSaveToFiles.d.ts","sourceRoot":"","sources":["../../src/storage/useSaveToFiles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAIxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAuB7D,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,CAAC,MAAM,EAAE;QAAE,MAAM,EAAE,iBAAiB,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACxF,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,+FAA+F;AAC/F,KAAK,oBAAoB,GAAG,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,oBAAoB,EAC5B,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC,CAYjB;AAED,wBAAgB,cAAc,IAAI,oBAAoB,CAqErD"}
+{"version":3,"file":"useSaveToFiles.d.ts","sourceRoot":"","sources":["../../src/storage/useSaveToFiles.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAIxD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAGL,KAAK,sBAAsB,EAC5B,MAAM,cAAc,CAAC;AAsBtB,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,CAAC,MAAM,EAAE;QACb,MAAM,EAAE,iBAAiB,CAAC;QAC1B,UAAU,EAAE,MAAM,CAAC;QACnB;;;;WAIG;QACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,sBAAsB,KAAK,IAAI,CAAC;KACpD,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;;OAKG;IACH,KAAK,EAAE,sBAAsB,GAAG,IAAI,CAAC;CACtC;AAED,+FAA+F;AAC/F,KAAK,oBAAoB,GAAG,IAAI,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC;AAEzD,MAAM,WAAW,oBAAoB;IACnC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,sBAAsB,KAAK,IAAI,CAAC;IACnD;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,oBAAoB,EAC5B,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,MAAM,CAAC,CA4BjB;AAED,wBAAgB,cAAc,IAAI,oBAAoB,CAsFrD"}

package/dist/storage/useSaveToFiles.js

@@ -1,9 +1,10 @@
-import { FILES_AFTER_SAVE_REFETCH as e, extractErrorMessage as t, uploadBlobToFiles as n } from "./uploadBlob.js";
-import { useState as r } from "react";
-import { gql as i } from "@apollo/client";
-import { useApolloClient as a } from "@apollo/client/react";
+import { extractErrorMessage as e, runWithFilesRetry as t } from "./retryPolicy.js";
+import { FILES_AFTER_SAVE_REFETCH as n, uploadBlobToFiles as r } from "./uploadBlob.js";
+import { useState as i } from "react";
+import { gql as a } from "@apollo/client";
+import { useApolloClient as o } from "@apollo/client/react";
 //#region src/storage/useSaveToFiles.ts
-var o = i`
+var s = a`
   mutation SaveToFiles_EnsureFolderByPath($path: String!) {
     ensureFolderByPath(path: $path) {
       id
@@ -11,7 +12,7 @@ var o = i`
       path
     }
   }
-`, s = i`
+`, c = a`
   mutation SaveToFiles_SaveSandboxArtifact($input: SaveSandboxArtifactInput!) {
     saveSandboxArtifactToFiles(input: $input) {
       id
@@ -20,58 +21,79 @@ var o = i`
     }
   }
 `;
-async function c(e, n) {
-	let r = await e.mutate({
-		mutation: o,
-		variables: { path: n }
-	}), i = r.data?.ensureFolderByPath?.id;
-	if (i) return i;
-	throw Error(t(r.error) ?? `Could not resolve folder for path: ${n}`);
+async function l(n, r, i = {}) {
+	let a = await t(async () => {
+		let e = await n.mutate({
+			mutation: s,
+			variables: { path: r }
+		}), t = e.data?.ensureFolderByPath?.id;
+		return t ? {
+			ok: !0,
+			value: t
+		} : {
+			ok: !1,
+			error: e.error
+		};
+	}, {
+		...i.onRetry ? { onRetry: (e) => i.onRetry?.({
+			...e,
+			step: "folder"
+		}) } : {},
+		...i.now ? { now: i.now } : {},
+		...i.sleep ? { sleep: i.sleep } : {}
+	});
+	if (a.value !== void 0) return a.value;
+	throw Error(e(a.error) ?? `Could not resolve folder for path: ${r}`);
 }
-function l() {
-	let i = a(), [o, l] = r(!1), [u, d] = r(null), [f, p] = r(0);
+function u() {
+	let t = o(), [a, s] = i(!1), [u, d] = i(null), [f, p] = i(0), [m, h] = i(null);
 	return {
-		save: async (r) => {
-			l(!0), d(null), p(0);
+		save: async (i) => {
+			s(!0), d(null), p(0), h(null);
+			let a = (e) => {
+				h(e), i.onRetry?.(e);
+			};
 			try {
-				let a = await c(i, r.folderPath);
-				if (r.source.kind === "sandbox-artifact") {
-					let n = await i.mutate({
-						mutation: s,
+				let o = await l(t, i.folderPath, { onRetry: a });
+				if (h(null), i.source.kind === "sandbox-artifact") {
+					let r = await t.mutate({
+						mutation: c,
 						variables: { input: {
-							sandboxId: r.source.sandboxId,
-							sessionId: r.source.sessionId,
-							path: r.source.path,
-							folderId: a,
-							filename: r.source.filename ?? null
+							sandboxId: i.source.sandboxId,
+							sessionId: i.source.sessionId,
+							path: i.source.path,
+							folderId: o,
+							filename: i.source.filename ?? null
 						} },
-						refetchQueries: e
-					}), o = n.data?.saveSandboxArtifactToFiles;
-					if (!o) throw Error(t(n.error) ?? "saveSandboxArtifactToFiles returned no file");
-					return p(100), o;
+						refetchQueries: n
+					}), a = r.data?.saveSandboxArtifactToFiles;
+					if (!a) throw Error(e(r.error) ?? "saveSandboxArtifactToFiles returned no file");
+					return p(100), a;
 				}
-				let o = await r.source.getBlob();
-				if (!o) throw Error("Cancelled: no bytes to save");
-				let l = o.blob;
-				return await n({
-					client: i,
-					blob: l,
-					filename: o.filename ?? r.source.filename,
-					mimeType: o.mimeType ?? r.source.mimeType,
-					folderId: a,
-					onProgress: p
+				let s = await i.source.getBlob();
+				if (!s) throw Error("Cancelled: no bytes to save");
+				let u = s.blob;
+				return await r({
+					client: t,
+					blob: u,
+					filename: s.filename ?? i.source.filename,
+					mimeType: s.mimeType ?? i.source.mimeType,
+					folderId: o,
+					onProgress: p,
+					onRetry: a
 				});
 			} catch (e) {
 				let t = e instanceof Error ? e : Error(String(e));
 				throw d(t), t;
 			} finally {
-				l(!1);
+				s(!1), h(null);
 			}
 		},
-		isPending: o,
+		isPending: a,
 		error: u,
-		progress: f
+		progress: f,
+		retry: m
 	};
 }
 //#endregion
-export { l as useSaveToFiles };
+export { u as useSaveToFiles };

package/dist/storage/warmFilesService.d.ts

@@ -0,0 +1,33 @@
+import { ApolloClient } from '@apollo/client';
+/**
+ * How long a successful warm-up is assumed to hold. Azure Container Apps scales a
+ * revision back to zero after ~300s idle, so anything under that is a wasted request
+ * — the container is still up. 240s leaves headroom without letting the window lapse.
+ */
+export declare const FILES_WARMUP_COOLDOWN_MS = 240000;
+/** Test seam — module state is a browser-lifetime singleton in real use. */
+export declare function __resetFilesWarmupForTests(): void;
+export interface WarmFilesServiceOptions {
+    /** Injected by tests. */
+    now?: () => number;
+    /** Skip the cooldown (for an explicit "the user is definitely about to upload"). */
+    force?: boolean;
+}
+/**
+ * Send one cheap files-svc read so a scaled-to-zero container starts booting.
+ *
+ * Never rejects and never throws — a failed warm-up is not a user-visible event.
+ * Concurrent callers share the in-flight promise; callers inside the cooldown window
+ * get an already-resolved one.
+ */
+export declare function warmFilesService(client: Pick<ApolloClient, 'query'>, options?: WarmFilesServiceOptions): Promise<void>;
+/**
+ * Fire a files-svc warm-up when `active` becomes true — e.g. when the assistant panel
+ * opens, so the container is booting while the user is still typing.
+ *
+ * The call site belongs to whoever owns the panel. In HealthyBowl that is
+ * `microfe-healthybowl`'s `AIAssistantPanel`, not fe-libs: fe-libs owns the mechanism
+ * (which query, single-flight, silence), the product owns the moment.
+ */
+export declare function useFilesServiceWarmup(active?: boolean): void;
+//# sourceMappingURL=warmFilesService.d.ts.map

package/dist/storage/warmFilesService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warmFilesService.d.ts","sourceRoot":"","sources":["../../src/storage/warmFilesService.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,OAAO,EAAO,KAAK,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAYxD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,SAAU,CAAC;AAOhD,4EAA4E;AAC5E,wBAAgB,0BAA0B,IAAI,IAAI,CAGjD;AAED,MAAM,WAAW,uBAAuB;IACtC,yBAAyB;IACzB,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;IACnB,oFAAoF;IACpF,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,EACnC,OAAO,GAAE,uBAA4B,GACpC,OAAO,CAAC,IAAI,CAAC,CA0Cf;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,OAAc,GAAG,IAAI,CAOlE"}

package/dist/storage/warmFilesService.js

@@ -0,0 +1,42 @@
+import { useEffect as e } from "react";
+import { gql as t } from "@apollo/client";
+import { useApolloClient as n } from "@apollo/client/react";
+//#region src/storage/warmFilesService.ts
+var r = t`
+  query FilesServiceWarmup($pagination: PaginationInput) {
+    getMyUploadSessions(pagination: $pagination) {
+      total
+    }
+  }
+`, i = 24e4, a = null, o = null;
+function s(e, t = {}) {
+	let n = t.now ?? (() => Date.now());
+	if (a) return a;
+	if (!t.force && o !== null && n() - o < 24e4) return Promise.resolve();
+	let i;
+	try {
+		i = Promise.resolve(e.query({
+			query: r,
+			variables: { pagination: {
+				limit: 1,
+				offset: 0
+			} },
+			fetchPolicy: "no-cache",
+			errorPolicy: "all"
+		}));
+	} catch {
+		i = Promise.resolve();
+	}
+	let s = i.then(() => void 0, () => void 0).then(() => {
+		o = n(), a = null;
+	});
+	return a = s, s;
+}
+function c(t = !0) {
+	let r = n();
+	e(() => {
+		t && s(r);
+	}, [t, r]);
+}
+//#endregion
+export { i as FILES_WARMUP_COOLDOWN_MS, c as useFilesServiceWarmup, s as warmFilesService };