@burdenoff/fe-libs 2026.813.2 → 2026.813.3

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

@@ -1 +1 @@
-{"version":3,"file":"SaveToFilesDialog.d.ts","sourceRoot":"","sources":["../../src/storage/SaveToFilesDialog.tsx"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElE,UAAU,KAAK;IACb,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;CACrC;AAED,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,iBAAiB,EACjB,QAAQ,EACR,OAAO,GACR,EAAE,KAAK,2CAwFP"}
+{"version":3,"file":"SaveToFilesDialog.d.ts","sourceRoot":"","sources":["../../src/storage/SaveToFilesDialog.tsx"],"names":[],"mappings":"AAyBA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAkB,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAElE,UAAU,KAAK;IACb,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,IAAI,CAAC;IACtC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,KAAK,IAAI,CAAC;CACrC;AAED,wBAAgB,iBAAiB,CAAC,EAChC,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,iBAAiB,EACjB,QAAQ,EACR,OAAO,GACR,EAAE,KAAK,2CA6GP"}

package/dist/storage/SaveToFilesDialog.js

@@ -8,7 +8,7 @@ import { useEffect as d, useState as f } from "react";
 import { Fragment as p, jsx as m, jsxs as h } from "react/jsx-runtime";
 //#region src/storage/SaveToFilesDialog.tsx
 function g({ open: g, onOpenChange: _, source: v, defaultFolderPath: y, filename: b, onSaved: x }) {
-	let [S, C] = f(y ?? "/Saved"), { save: w, isPending: T, error: E, progress: D } = u();
+	let [S, C] = f(y ?? "/Saved"), { save: w, isPending: T, error: E, progress: D, retry: O } = u();
 	return d(() => {
 		g && C(y ?? "/Saved");
 	}, [g, y]), /* @__PURE__ */ m(e, {
@@ -55,6 +55,21 @@ function g({ open: g, onOpenChange: _, source: v, defaultFolderPath: y, filename
 							style: { width: `${D}%` }
 						})
 					}),
+					T && O && /* @__PURE__ */ h("p", {
+						className: "text-xs text-muted-foreground",
+						role: "status",
+						"aria-live": "polite",
+						"data-testid": "save-to-files-retry",
+						children: [
+							O.kind === "cold-start" ? "The file service is starting up — retrying" : "Hit a hiccup — retrying",
+							" ",
+							"(attempt ",
+							O.attempt,
+							" of ",
+							O.maxAttempts,
+							")…"
+						]
+					}),
 					E && /* @__PURE__ */ m("p", {
 						className: "text-xs text-destructive",
 						"data-testid": "save-to-files-error",

package/dist/storage/index.d.ts

@@ -6,5 +6,8 @@ export { SaveToFilesDialog } from './SaveToFilesDialog';
 export { useSaveToFiles } from './useSaveToFiles';
 export type { SavedFile, UseSaveToFilesResult } from './useSaveToFiles';
 export { uploadBlobToFiles, FILES_AFTER_SAVE_REFETCH } from './uploadBlob';
-export type { UploadBlobParams, UploadedFile } from './uploadBlob';
+export type { UploadBlobParams, UploadedFile, SaveToFilesStep, SaveToFilesRetryNotice, } from './uploadBlob';
+export { classifyFilesError, decideFilesRetry, runWithFilesRetry, COLD_START_MAX_ATTEMPTS, COLD_START_RETRY_DELAYS_MS, COLD_START_RETRY_BUDGET_MS, } from './retryPolicy';
+export type { FilesRetryKind, FilesRetryDecision, FilesRetryNotice, FilesRetryContext, } from './retryPolicy';
+export { warmFilesService, useFilesServiceWarmup, FILES_WARMUP_COOLDOWN_MS, } from './warmFilesService';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC3E,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,YAAY,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,YAAY,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,iBAAiB,EAAE,wBAAwB,EAAE,MAAM,cAAc,CAAC;AAC3E,YAAY,EACV,gBAAgB,EAChB,YAAY,EACZ,eAAe,EACf,sBAAsB,GACvB,MAAM,cAAc,CAAC;AAItB,OAAO,EACL,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,uBAAuB,EACvB,0BAA0B,EAC1B,0BAA0B,GAC3B,MAAM,eAAe,CAAC;AACvB,YAAY,EACV,cAAc,EACd,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,GAClB,MAAM,eAAe,CAAC;AACvB,OAAO,EACL,gBAAgB,EAChB,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,oBAAoB,CAAC"}

package/dist/storage/index.js

@@ -1,6 +1,8 @@
 import { StorageFolderPicker as e } from "./StorageFolderPicker.js";
-import { FILES_AFTER_SAVE_REFETCH as t, uploadBlobToFiles as n } from "./uploadBlob.js";
-import { useSaveToFiles as r } from "./useSaveToFiles.js";
-import { SaveToFilesDialog as i } from "./SaveToFilesDialog.js";
-import { SaveToFilesButton as a } from "./SaveToFilesButton.js";
-export { t as FILES_AFTER_SAVE_REFETCH, a as SaveToFilesButton, i as SaveToFilesDialog, e as StorageFolderPicker, n as uploadBlobToFiles, r as useSaveToFiles };
+import { COLD_START_MAX_ATTEMPTS as t, COLD_START_RETRY_BUDGET_MS as n, COLD_START_RETRY_DELAYS_MS as r, classifyFilesError as i, decideFilesRetry as a, runWithFilesRetry as o } from "./retryPolicy.js";
+import { FILES_AFTER_SAVE_REFETCH as s, uploadBlobToFiles as c } from "./uploadBlob.js";
+import { useSaveToFiles as l } from "./useSaveToFiles.js";
+import { SaveToFilesDialog as u } from "./SaveToFilesDialog.js";
+import { SaveToFilesButton as d } from "./SaveToFilesButton.js";
+import { FILES_WARMUP_COOLDOWN_MS as f, useFilesServiceWarmup as p, warmFilesService as m } from "./warmFilesService.js";
+export { t as COLD_START_MAX_ATTEMPTS, n as COLD_START_RETRY_BUDGET_MS, r as COLD_START_RETRY_DELAYS_MS, s as FILES_AFTER_SAVE_REFETCH, f as FILES_WARMUP_COOLDOWN_MS, d as SaveToFilesButton, u as SaveToFilesDialog, e as StorageFolderPicker, i as classifyFilesError, a as decideFilesRetry, o as runWithFilesRetry, c as uploadBlobToFiles, p as useFilesServiceWarmup, l as useSaveToFiles, m as warmFilesService };

package/dist/storage/retryPolicy.d.ts

@@ -0,0 +1,179 @@
+/**
+ * retryPolicy — when a wspace-files-svc call through the workspace gateway is
+ * worth trying again, and how long to wait before doing so.
+ *
+ * ## Why this exists: a scale-to-zero cold start, measured in production
+ *
+ * `wspace-files-svc` runs at `minReplicas: 0`, 0.25 vCPU / 0.5 GiB, so after an
+ * idle period its revision sits at `replicas: 0, state: "ScaledToZero"`. Timed on
+ * the deployed image at that exact resource envelope:
+ *
+ *   bunx prisma migrate deploy   26.0s
+ *   app boot                    ~25.5s
+ *   ------------------------------------
+ *   >= 51s before the port binds
+ *
+ * The gateway's per-operation budget is `OPERATION_TIMEOUT_MS = 15_000`. The first
+ * request after a quiet period therefore CANNOT succeed: it wakes the container and
+ * is then abandoned ~36s before that container can answer.
+ *
+ * Seven-attempt production reproduction, same 1,305-byte file, idle gaps
+ * 0/5/40/5/40/90/5s:
+ *
+ *   #1  16.2s  FAIL  "Operation timeout"  {"code":"OPERATION_TIMEOUT","timeoutMs":15000}
+ *   #2  16.2s  OK    #3 6.1s OK   #4 6.1s OK   #5 6.1s OK   #6 2.1s OK   #7 2.1s OK
+ *
+ * Only the first attempt fails; everything after it is warm and gets faster. With a
+ * 300s Azure Container Apps cooldown, a real user's first attachment after any quiet
+ * period lands on exactly this. The proper fix is `minReplicas: 1` — that needs Azure
+ * access, so this module is the client-side half that makes the cold start survivable
+ * meanwhile. Several services in this fleet are scale-to-zero, so it is not a
+ * one-off workaround.
+ *
+ * ## Two retry classes, deliberately different
+ *
+ * - `cold-start`  — the gateway gave up waiting (`OPERATION_TIMEOUT` and friends).
+ *                   The container is probably still booting, so the delays are sized
+ *                   in TENS of seconds. A single immediate retry is useless here.
+ * - `transient-blip` — a masked `INTERNAL_SERVER_ERROR` or a bare network error, the
+ *                   pre-existing `completeUpload` case (a brief Azure Managed Redis
+ *                   slowdown). Sub-second delays, unchanged from before this module.
+ *
+ * ## What is NEVER retried
+ *
+ * Classification is an ALLOWLIST: an unrecognised code is not retried. On top of
+ * that, `NEVER_RETRY_CODES` is a hard stop — if a quota rejection, an auth failure
+ * or any other 4xx-class business error appears anywhere in the error, the whole
+ * error is unretryable even if a timeout also appears. Retrying those is pure harm:
+ * the answer will not change and the user waits a minute to be told the same thing.
+ */
+/** How an error should be retried, or `null` for "do not retry this". */
+export type FilesRetryKind = 'cold-start' | 'transient-blip';
+/**
+ * Attempt ceiling for a cold start. Three attempts, and the third one starts at
+ * roughly t+61s:
+ *
+ *   attempt 1  t=0   -> gateway gives up at ~16s
+ *   wait 10s
+ *   attempt 2  t=26  -> gateway gives up at ~41s
+ *   wait 20s
+ *   attempt 3  t=61  -> container bound its port at ~51s, so this is the one that lands
+ *
+ * The container's boot clock starts when attempt 1 reaches the ACA ingress, which is
+ * why the ladder is measured from the FIRST attempt and not from each failure. The
+ * numbers above come from the measurement at the top of this file: >=51s to port
+ * bind, 15s gateway budget. Change them if that measurement changes, not before.
+ */
+export declare const COLD_START_MAX_ATTEMPTS = 3;
+/** Delay before cold-start attempt 2, then before attempt 3. See the ladder above. */
+export declare const COLD_START_RETRY_DELAYS_MS: readonly number[];
+/**
+ * Hard wall-clock ceiling for one operation's cold-start retries, measured from the
+ * first attempt. The ladder above tops out at ~76s of real time; this stops a
+ * pathologically slow gateway from stretching that indefinitely. Past this, we give
+ * up honestly and show the user the real error.
+ */
+export declare const COLD_START_RETRY_BUDGET_MS = 75000;
+/** Attempt ceiling for a transient blip — unchanged from the pre-existing behaviour. */
+export declare const BLIP_MAX_ATTEMPTS = 3;
+/** Delays before blip attempts 2 and 3 — unchanged from the pre-existing behaviour. */
+export declare const BLIP_RETRY_DELAYS_MS: readonly number[];
+/**
+ * Best-effort message extraction, preferring the first GraphQL error's message
+ * (Apollo v4 `CombinedGraphQLErrors.errors`, or v3 `.graphQLErrors`) so callers can
+ * surface the real reason instead of a generic envelope.
+ *
+ * Lives here rather than in `uploadBlob` because both the upload path and the folder
+ * path need it and both now sit on top of this module. `uploadBlob` re-exports it, so
+ * its public name is unchanged.
+ */
+export declare function extractErrorMessage(err: unknown): string | undefined;
+/**
+ * Decide what KIND of failure this is, or `null` if it must not be retried.
+ *
+ * Pure. This is the whole safety argument in one function, so it is unit-tested
+ * directly rather than only through the upload path.
+ */
+export declare function classifyFilesError(err: unknown): FilesRetryKind | null;
+export interface FilesRetryContext {
+    /** 1-based index of the attempt that just failed. */
+    attempt: number;
+    /** Milliseconds since the FIRST attempt started (the container's boot clock). */
+    elapsedMs: number;
+    /** Which classes this call site permits. Defaults to cold-start only. */
+    allow?: readonly FilesRetryKind[];
+}
+export type FilesRetryDecision = {
+    retry: true;
+    kind: FilesRetryKind;
+    /** How long to wait before the next attempt. */
+    delayMs: number;
+    /** 1-based number of the attempt that is about to run. */
+    nextAttempt: number;
+    maxAttempts: number;
+} | {
+    retry: false;
+    reason: 'not-retryable' | 'kind-not-allowed' | 'attempts-exhausted' | 'budget-exhausted';
+};
+/**
+ * The retry policy as a pure function: given the error and where we are, should we go
+ * again and after how long?
+ *
+ * Separated from any I/O so the safety properties can be asserted directly — retries
+ * on a gateway timeout, does NOT retry a quota/auth/4xx rejection, respects the
+ * attempt ceiling and the wall-clock budget, and reports honestly why it stopped.
+ */
+export declare function decideFilesRetry(err: unknown, ctx: FilesRetryContext): FilesRetryDecision;
+/** What one attempt reports back to the runner. */
+export type FilesAttemptResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: unknown;
+};
+/** Handed to `onRetry` just before the runner sleeps. Enough to render honest UI. */
+export interface FilesRetryNotice {
+    kind: FilesRetryKind;
+    /** 1-based number of the attempt about to run (2 means "second try"). */
+    attempt: number;
+    maxAttempts: number;
+    /** How long the runner is about to wait. */
+    delayMs: number;
+    /** The failure that triggered the retry, for logging — never for the user. */
+    error: unknown;
+}
+export interface RunWithFilesRetryOptions {
+    /** Which classes this call site permits. Defaults to cold-start only. */
+    allow?: readonly FilesRetryKind[];
+    /** Fired before each wait, so the UI can say what it is waiting for. */
+    onRetry?: (notice: FilesRetryNotice) => void;
+    /** Injected by tests. */
+    now?: () => number;
+    /** Injected by tests. */
+    sleep?: (ms: number) => Promise<void>;
+}
+export interface FilesRetryOutcome<T> {
+    /** Present only on success. */
+    value?: T;
+    /** The last in-band error, when `value` is absent. */
+    error?: unknown;
+    /** How many attempts were actually made. */
+    attempts: number;
+    /** Why we stopped, when `value` is absent. */
+    gaveUpBecause?: 'not-retryable' | 'kind-not-allowed' | 'attempts-exhausted' | 'budget-exhausted';
+}
+/**
+ * Run `attempt` until it succeeds, the policy says stop, or the budget runs out.
+ *
+ * Two failure channels, on purpose:
+ *
+ * - A THROWN error is classified and, if unretryable, rethrown **as-is**. Identity
+ *   and stack are preserved, so callers that let network errors through untouched
+ *   keep doing exactly that.
+ * - An IN-BAND error (`{ ok: false, error }` — what `errorPolicy: 'all'` produces on
+ *   `result.error`) is returned in the outcome. The runner never invents a message
+ *   for it; the caller owns the wording, which is what fe-libs #132 established.
+ */
+export declare function runWithFilesRetry<T>(attempt: (attemptNumber: number) => Promise<FilesAttemptResult<T>>, options?: RunWithFilesRetryOptions): Promise<FilesRetryOutcome<T>>;
+//# sourceMappingURL=retryPolicy.d.ts.map

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

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

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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burdenoff/fe-libs",
-  "version": "2026.813.2",
+  "version": "2026.813.3",
   "description": "Burdenoff frontend primitives and domain libraries",
   "type": "module",
   "bin": {
@@ -284,7 +284,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": "bun test scripts/graphql-schema-drift/__tests__ src/credentials src/shared/providers/AppShellProvider.test.ts src/shared/events/sinks/RybbitSink.test.ts",
+    "test": "bun test scripts/graphql-schema-drift/__tests__ src/credentials src/storage src/shared/providers/AppShellProvider.test.ts src/shared/events/sinks/RybbitSink.test.ts",
     "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",
     "switch:remote": "bun scripts/deps-mode.ts remote",