@ai-matrx/media 0.5.12 → 0.6.1

package/dist/react.js

@@ -725,7 +725,7 @@ function useMediaLoadRecovery(src, options) {
   const recoverable = options?.recoverable !== false;
   const onTerminal = options?.onTerminal;
   const failureRef = options?.failureRef;
-  const [result, setResult] = useState3({ source: src, retryKey: 0, failed: false });
+  const [result, setResult] = useState3({ source: src, retryKey: 0, failed: false, healedSrc: null });
   const attemptRef = useRef3(0);
   const recoveryInFlightRef = useRef3(false);
   useEffect3(() => {
@@ -739,7 +739,7 @@ function useMediaLoadRecovery(src, options) {
   const onLoadError = (event) => {
     if (recoveryInFlightRef.current) return;
     if (!src || !recoverable) {
-      setResult({ source: src, retryKey: 0, failed: true });
+      setResult({ source: src, retryKey: 0, failed: true, healedSrc: null });
       if (src) {
         capture({
           phase: "element-load",
@@ -770,23 +770,90 @@ function useMediaLoadRecovery(src, options) {
           setResult((current) => ({
             source: src,
             retryKey: current.source === src ? current.retryKey + 1 : 1,
-            failed: false
+            failed: false,
+            healedSrc: null
           }));
-        } else {
-          setResult({ source: src, retryKey: 0, failed: true });
+          return;
+        }
+        const lane1 = {
+          lane: "session-refresh-retry",
+          outcome: attempt > 1 ? "http-error" : "unavailable",
+          ms: 0,
+          ...report.status !== void 0 ? { status: report.status } : {},
+          detail: attempt > 1 ? "cookie re-minted, same durable URL retried in the element, element errored again" : "recovery declined on the first attempt (no usable session)"
+        };
+        if (!failureRef || !client.healLoadError) {
+          setResult({ source: src, retryKey: 0, failed: true, healedSrc: null });
           capture({
             phase: attempt > 1 ? "element-load" : "recovery",
             mediaRef: identity(),
             terminal: true,
             retryOutcome: attempt > 1 ? "retried" : "not-attempted",
-            message: attempt > 1 ? "media element failed to load after the session-refresh retry" : "media load recovery declined on the first attempt (session refresh did not produce a usable session)",
+            message: (attempt > 1 ? "media element failed to load after the session-refresh retry" : "media load recovery declined on the first attempt (session refresh did not produce a usable session)") + (failureRef ? " \u2014 no heal ladder on this client (healLoadError not implemented)" : " \u2014 no durable ref supplied, so no heal lane could run"),
             ...report.status !== void 0 ? { status: report.status } : {}
           });
           onTerminal?.(event);
+          return;
         }
+        const heal = client.healLoadError(failureRef, {
+          src: mintDurableSrc(src),
+          attempts: [lane1]
+        });
+        heal.then(
+          (verdict) => {
+            if (verdict.src) {
+              setResult({
+                source: src,
+                retryKey: 0,
+                failed: false,
+                healedSrc: verdict.src
+              });
+              capture({
+                phase: "heal",
+                mediaRef: identity(),
+                terminal: false,
+                healed: true,
+                healedBy: verdict.healedBy,
+                attempts: verdict.attempts,
+                diagnosis: verdict.diagnosis,
+                retryOutcome: "retried",
+                message: `HEALED (${verdict.healedBy ?? "unknown lane"}): ${verdict.summary}`,
+                ...report.status !== void 0 ? { status: report.status } : {}
+              });
+              return;
+            }
+            setResult({ source: src, retryKey: 0, failed: true, healedSrc: null });
+            capture({
+              phase: "heal",
+              mediaRef: identity(),
+              terminal: true,
+              healed: false,
+              attempts: verdict.attempts,
+              diagnosis: verdict.diagnosis,
+              retryOutcome: "retried",
+              message: `DEAD after ${verdict.attempts.length} lane(s): ${verdict.summary}`,
+              ...report.status !== void 0 ? { status: report.status } : {}
+            });
+            onTerminal?.(event);
+          },
+          (err) => {
+            setResult({ source: src, retryKey: 0, failed: true, healedSrc: null });
+            capture({
+              phase: "heal",
+              mediaRef: identity(),
+              terminal: true,
+              healed: false,
+              attempts: [lane1],
+              diagnosis: "unknown",
+              retryOutcome: "recovery-failed",
+              message: `heal ladder threw: ${err instanceof Error ? err.message : String(err ?? "unknown error")}`
+            });
+            onTerminal?.(event);
+          }
+        );
       },
       (err) => {
-        setResult({ source: src, retryKey: 0, failed: true });
+        setResult({ source: src, retryKey: 0, failed: true, healedSrc: null });
         capture({
           phase: "session",
           mediaRef: identity(),
@@ -801,7 +868,8 @@ function useMediaLoadRecovery(src, options) {
   return {
     retryKey: result.source === src ? result.retryKey : 0,
     onLoadError,
-    failed: result.source === src ? result.failed : false
+    failed: result.source === src ? result.failed : false,
+    healedSrc: result.source === src ? result.healedSrc : null
   };
 }
 
@@ -1130,15 +1198,16 @@ function InlineMediaRef({
     resolution && (resolution.transport === "blob" || crossOrigin && resolution.isCdn !== true)
   );
   const blob = useMediaBlob(needsBlob ? mediaRef : null);
-  const url = needsBlob ? blob.url : resolution?.src ?? null;
+  const resolvedUrl = needsBlob ? blob.url : resolution?.src ?? null;
   const terminalCallback = (event) => onError?.(
     event
   );
-  const recovery = useMediaLoadRecovery(url, {
+  const recovery = useMediaLoadRecovery(resolvedUrl, {
     recoverable: resolution?.recoverable !== false,
     failureRef: mediaRef,
     onTerminal: terminalCallback
   });
+  const url = recovery.healedSrc ?? resolvedUrl;
   const blobRecovery = useMediaBlobLoadRecovery(
     needsBlob ? mediaRef : null,
     needsBlob ? url : null,
@@ -1533,18 +1602,19 @@ function ImageThumb({
   blobRecovery,
   fallback
 }) {
-  const { retryKey, onLoadError, failed } = useMediaLoadRecovery(url, {
+  const { retryKey, onLoadError, failed, healedSrc } = useMediaLoadRecovery(url, {
     recoverable,
     failureRef: mediaRef
   });
   const activeRecovery = blobBacked ? { retryKey: 0, ...blobRecovery } : { retryKey, onLoadError, failed };
+  const renderUrl = !blobBacked && healedSrc || url;
   if (activeRecovery.failed) return /* @__PURE__ */ jsx4(Fragment2, { children: fallback });
   return /* @__PURE__ */ jsx4(
     "img",
     {
-      src: url,
+      src: renderUrl,
       alt,
-      loading: url.startsWith("blob:") ? "eager" : "lazy",
+      loading: renderUrl.startsWith("blob:") ? "eager" : "lazy",
       className: "h-full w-full object-cover",
       onError: activeRecovery.onLoadError
     },
@@ -1559,11 +1629,12 @@ function VideoPosterThumb({
   blobRecovery,
   fallback
 }) {
-  const { retryKey, onLoadError, failed } = useMediaLoadRecovery(url, {
+  const { retryKey, onLoadError, failed, healedSrc } = useMediaLoadRecovery(url, {
     recoverable,
     failureRef: mediaRef
   });
   const activeRecovery = blobBacked ? { retryKey: 0, ...blobRecovery } : { retryKey, onLoadError, failed };
+  const renderUrl = !blobBacked && healedSrc || url;
   const ref = useRef5(null);
   useEffect6(() => {
     const v = ref.current;
@@ -1582,7 +1653,7 @@ function VideoPosterThumb({
     "video",
     {
       ref,
-      src: url,
+      src: renderUrl,
       className: "h-full w-full object-cover pointer-events-none",
       preload: "metadata",
       muted: true,