livedesk 0.1.607 → 0.1.609

package/electron/runtime-window-load-owner.mjs

@@ -0,0 +1,153 @@
+const DEFAULT_RETRY_DELAY_MS = 1_000;
+
+function normalizeDelay(value, fallback = 0) {
+  const milliseconds = Number(value);
+  return Number.isFinite(milliseconds) && milliseconds >= 0
+    ? Math.round(milliseconds)
+    : fallback;
+}
+
+/**
+ * Owns the one retry timer and one in-flight load attempt for a BrowserWindow.
+ * A successfully mounted runtime document is never reloaded by start(). Only a
+ * real main-frame failure or renderer termination opens a new generation.
+ */
+export function createRuntimeWindowLoadOwner({
+  probeRuntime,
+  showRecovery = async () => undefined,
+  loadRuntime,
+  onLoaded = () => undefined,
+  onAttemptError = () => undefined,
+  retryDelayMs = DEFAULT_RETRY_DELAY_MS,
+  setTimer = setTimeout,
+  clearTimer = clearTimeout
+} = {}) {
+  if (typeof probeRuntime !== 'function') throw new Error('runtime-window-probe-required');
+  if (typeof loadRuntime !== 'function') throw new Error('runtime-window-loader-required');
+
+  const retryDelay = normalizeDelay(retryDelayMs, DEFAULT_RETRY_DELAY_MS);
+  let generation = 1;
+  let stopped = false;
+  let loaded = false;
+  let recoveryVisible = false;
+  let timer = null;
+  let operation = null;
+  let attemptCount = 0;
+  let pendingReason = 'created';
+  let pendingRetryDelay = retryDelay;
+
+  const snapshot = () => ({
+    generation,
+    stopped,
+    loaded,
+    recoveryVisible,
+    retryScheduled: timer !== null,
+    attemptPending: operation !== null,
+    attemptCount,
+    pendingReason
+  });
+
+  const reportAttemptError = (error, context) => {
+    try {
+      onAttemptError(error, context);
+    } catch {
+      // Diagnostics cannot take ownership from the load recovery path.
+    }
+  };
+
+  const ensureRecoveryVisible = async context => {
+    if (stopped || loaded || recoveryVisible || context.generation !== generation) return;
+    try {
+      await showRecovery(context);
+      if (!stopped && !loaded && context.generation === generation) recoveryVisible = true;
+    } catch (error) {
+      reportAttemptError(error, { ...context, phase: 'recovery-page' });
+    }
+  };
+
+  const schedule = (reason = 'retry', delayMs = 0) => {
+    if (stopped || loaded || timer !== null || operation !== null) return false;
+    pendingReason = String(reason || 'retry');
+    const ownerGeneration = generation;
+    timer = setTimer(() => {
+      timer = null;
+      if (stopped || loaded || ownerGeneration !== generation) return;
+      const context = {
+        generation: ownerGeneration,
+        attempt: ++attemptCount,
+        reason: pendingReason
+      };
+      const currentOperation = (async () => {
+        const ready = await probeRuntime(context);
+        if (stopped || loaded || ownerGeneration !== generation) return;
+        if (!ready) {
+          await ensureRecoveryVisible({ ...context, phase: 'runtime-wait' });
+          return;
+        }
+        await loadRuntime(context);
+        if (stopped || loaded || ownerGeneration !== generation) return;
+        loaded = true;
+        recoveryVisible = false;
+        try {
+          onLoaded(context);
+        } catch (error) {
+          reportAttemptError(error, { ...context, phase: 'loaded-callback' });
+        }
+      })()
+        .catch(async error => {
+          if (stopped || loaded || ownerGeneration !== generation) return;
+          reportAttemptError(error, { ...context, phase: 'runtime-load' });
+          await ensureRecoveryVisible({ ...context, phase: 'runtime-load' });
+        })
+        .finally(() => {
+          if (operation !== currentOperation) return;
+          operation = null;
+          if (!stopped && !loaded) {
+            const delay = pendingRetryDelay;
+            pendingRetryDelay = retryDelay;
+            schedule(pendingReason || 'retry', delay);
+          }
+        });
+      operation = currentOperation;
+    }, normalizeDelay(delayMs));
+    timer?.unref?.();
+    return true;
+  };
+
+  const beginNewGeneration = reason => {
+    if (stopped) return false;
+    generation += 1;
+    loaded = false;
+    recoveryVisible = false;
+    pendingReason = String(reason || 'reload');
+    pendingRetryDelay = 0;
+    if (timer !== null) {
+      clearTimer(timer);
+      timer = null;
+    }
+    schedule(pendingReason, 0);
+    return true;
+  };
+
+  return {
+    getStatus: snapshot,
+    start(reason = 'start') {
+      return schedule(reason, 0);
+    },
+    noteMainFrameFailure(reason = 'main-frame-failed') {
+      return beginNewGeneration(reason);
+    },
+    noteRendererGone(reason = 'renderer-gone') {
+      return beginNewGeneration(reason);
+    },
+    stop() {
+      if (stopped) return;
+      stopped = true;
+      generation += 1;
+      if (timer !== null) {
+        clearTimer(timer);
+        timer = null;
+      }
+    }
+  };
+}