@microbt/pwa 0.0.0-stage → 0.1.0

package/dist/esm/shared/pwa.js

@@ -0,0 +1,231 @@
+// src/shared/pwa.ts
+import { arms } from "@microbt/environment";
+import {
+  countRegistrationFailure,
+  createRegistrationError,
+  registrationErrorMessage
+} from "./pwa-registration-telemetry";
+import { SwRegistrationRetry } from "./pwa-retry";
+import { removeInvalidRegistrations, resolveSwRegisterUrl } from "./sw-registration";
+var PwaRegistrationScheduler = class {
+  constructor(options) {
+    this.options = options;
+    this.scheduleStarted = false;
+    this.firstPaintQueued = false;
+    this.registrationCompleted = false;
+    this.registrationInFlight = null;
+    this.idleHandle = null;
+    this.timeoutHandle = null;
+    this.visibilityListenerAttached = false;
+    this.onlineListenerAttached = false;
+    this.retry = new SwRegistrationRetry(
+      () => this.registrationCompleted,
+      () => {
+        void this.registerServiceWorker();
+      },
+      (message, ...args) => this.options.log(message, ...args)
+    );
+    this.clearPendingRegistrationTask = () => {
+      const idleWindow = this.getIdleWindow();
+      if (this.idleHandle !== null && idleWindow.cancelIdleCallback) {
+        idleWindow.cancelIdleCallback(this.idleHandle);
+        this.idleHandle = null;
+      }
+      if (this.timeoutHandle !== null) {
+        window.clearTimeout(this.timeoutHandle);
+        this.timeoutHandle = null;
+      }
+    };
+    this.detachReadinessListeners = () => {
+      if (this.visibilityListenerAttached) {
+        document.removeEventListener("visibilitychange", this.handleReadinessChange);
+        this.visibilityListenerAttached = false;
+      }
+      if (this.onlineListenerAttached) {
+        window.removeEventListener("online", this.handleReadinessChange);
+        this.onlineListenerAttached = false;
+      }
+    };
+    this.attachReadinessListeners = () => {
+      if (!this.visibilityListenerAttached) {
+        document.addEventListener("visibilitychange", this.handleReadinessChange);
+        this.visibilityListenerAttached = true;
+      }
+      if (!this.onlineListenerAttached) {
+        window.addEventListener("online", this.handleReadinessChange);
+        this.onlineListenerAttached = true;
+      }
+    };
+    this.queueRegistrationWhenIdle = () => {
+      if (this.registrationCompleted || this.registrationInFlight) {
+        this.detachReadinessListeners();
+        return;
+      }
+      if (document.visibilityState !== "visible" || !navigator.onLine) {
+        this.waitUntilPageReady();
+        return;
+      }
+      if (this.idleHandle !== null || this.timeoutHandle !== null) {
+        return;
+      }
+      const runRegistration = () => {
+        this.idleHandle = null;
+        this.timeoutHandle = null;
+        if (document.visibilityState !== "visible" || !navigator.onLine) {
+          this.waitUntilPageReady();
+          return;
+        }
+        void this.registerServiceWorker();
+      };
+      const idleWindow = this.getIdleWindow();
+      if (idleWindow.requestIdleCallback) {
+        this.idleHandle = idleWindow.requestIdleCallback(runRegistration, {
+          timeout: 3e3
+        });
+        return;
+      }
+      this.timeoutHandle = window.setTimeout(runRegistration, 3e3);
+    };
+    this.scheduleAfterFirstPaint = () => {
+      if (this.firstPaintQueued || this.registrationCompleted || this.registrationInFlight) {
+        return;
+      }
+      this.firstPaintQueued = true;
+      window.requestAnimationFrame(() => {
+        window.requestAnimationFrame(() => {
+          this.firstPaintQueued = false;
+          this.queueRegistrationWhenIdle();
+        });
+      });
+    };
+    this.waitUntilPageReady = () => {
+      this.clearPendingRegistrationTask();
+      if (document.visibilityState === "visible" && navigator.onLine) {
+        this.detachReadinessListeners();
+        this.scheduleAfterFirstPaint();
+        return;
+      }
+      this.attachReadinessListeners();
+    };
+    this.handleReadinessChange = () => {
+      if (this.registrationCompleted || this.registrationInFlight) {
+        this.detachReadinessListeners();
+        return;
+      }
+      this.waitUntilPageReady();
+    };
+    this.registerServiceWorker = async () => {
+      if (this.registrationCompleted) {
+        return;
+      }
+      if (this.registrationInFlight) {
+        await this.registrationInFlight;
+        return;
+      }
+      this.registrationInFlight = (async () => {
+        var _a;
+        let swRegisterUrl = null;
+        let stage = "load-workbox";
+        try {
+          const { Workbox } = await import("workbox-window");
+          stage = "resolve-url";
+          swRegisterUrl = await resolveSwRegisterUrl({
+            version: this.options.version
+          });
+          stage = "register-sw";
+          const wb = new Workbox(swRegisterUrl);
+          const startTime = +/* @__PURE__ */ new Date();
+          wb.addEventListener("installed", () => {
+            const endTime = +/* @__PURE__ */ new Date();
+            this.options.log(
+              `Service Worker installed:${endTime}, time taken:${endTime - startTime}`
+            );
+          });
+          wb.addEventListener("activated", () => {
+            this.options.log(
+              `Service Worker activated:${+/* @__PURE__ */ new Date()}, online status: ${navigator.onLine}`
+            );
+            if (!navigator.onLine) {
+              arms.sum("PWA-ACTIVATED-OFFLINE");
+            }
+          });
+          wb.addEventListener("controlling", () => {
+            this.options.log(`Service Worker has taken control of the current client:${+/* @__PURE__ */ new Date()}`);
+          });
+          wb.addEventListener("waiting", () => {
+            this.options.log(`Service Worker is waiting:${+/* @__PURE__ */ new Date()}`);
+          });
+          const res = await wb.register();
+          this.options.log(
+            `Service Worker registration successful:${startTime}, state: ${(_a = res == null ? void 0 : res.active) == null ? void 0 : _a.state}, installing: ${res == null ? void 0 : res.installing}, host:${location.host}`
+          );
+          arms.sum("PWA-REGISTER-SUCCESS");
+          this.retry.onSuccess();
+          this.registrationCompleted = true;
+        } catch (e) {
+          if (this.shouldIgnoreError(e)) {
+            this.retry.stop();
+            this.options.log(
+              `Service Worker registration restricted (report ignored): ${registrationErrorMessage(
+                e
+              )}`
+            );
+            return;
+          }
+          const error = createRegistrationError(e, stage);
+          this.retry.reportErrorOnce(error);
+          countRegistrationFailure(stage);
+          this.retry.scheduleRetry();
+          this.options.log(`Service Worker registration failed: ${error.message}`, error);
+        } finally {
+          this.registrationInFlight = null;
+          this.clearPendingRegistrationTask();
+          this.detachReadinessListeners();
+        }
+        if (this.registrationCompleted && swRegisterUrl !== null) {
+          try {
+            await removeInvalidRegistrations(
+              swRegisterUrl,
+              (message, ...args) => this.options.log(message, ...args)
+            );
+          } catch (e) {
+            this.options.log(`清理历史 SW 注册失败（不影响本次注册）: ${e.message}`);
+          }
+        }
+      })();
+      await this.registrationInFlight;
+    };
+    this.schedule = () => {
+      if (this.scheduleStarted) {
+        return;
+      }
+      if (typeof window === "undefined" || typeof document === "undefined" || // WebView / opaque origin 下 serviceWorker 属性存在但值为 null，
+      // 必须用真值检查而非 'serviceWorker' in navigator
+      !navigator.serviceWorker) {
+        return;
+      }
+      this.scheduleStarted = true;
+      this.waitUntilPageReady();
+    };
+  }
+  shouldIgnoreError(error) {
+    const errorMessages = [
+      "Job rejected for non app-bound domain"
+      // iOS PWA注册限制错误
+      // 'The operation is insecure', // 某些浏览器安全限制错误
+      // 'Failed to register a ServiceWorker', // 通用注册失败错误
+    ];
+    return errorMessages.some((msg) => registrationErrorMessage(error).includes(msg));
+  }
+  getIdleWindow() {
+    return window;
+  }
+};
+var pwaRegistrationScheduler = null;
+var schedulePwaRegistration = (options) => {
+  pwaRegistrationScheduler ??= new PwaRegistrationScheduler(options);
+  pwaRegistrationScheduler.schedule();
+};
+export {
+  schedulePwaRegistration
+};

package/dist/esm/shared/sw-registration.d.ts

@@ -0,0 +1,11 @@
+import type { PwaLog } from './pwa';
+/** 解析本次应注册的 SW 地址（在线/离线/同构建复用，见 sw-script-url.ts） */
+export declare function resolveSwRegisterUrl(options: {
+    version: string;
+}): Promise<string>;
+/**
+ * 历史注册清理：注销与本次注册地址不同（规范化比较，消除绝对/相对差异）
+ * 的本站 /sw.js 注册。必须在 register 成功之后调用——若 register 失败
+ * 直接跳过，保证任何时候不把正在使用的注册注销掉。
+ */
+export declare function removeInvalidRegistrations(keepScriptUrl: string, log: PwaLog): Promise<void>;

package/dist/esm/shared/sw-registration.js

@@ -0,0 +1,35 @@
+// src/shared/sw-registration.ts
+import { isSameOriginSwScriptUrl, normalizeScriptUrl, resolveSwScriptUrl } from "./sw-script-url";
+function getRegistrationScriptUrl(registration) {
+  var _a, _b, _c;
+  return ((_a = registration.active) == null ? void 0 : _a.scriptURL) ?? ((_b = registration.waiting) == null ? void 0 : _b.scriptURL) ?? ((_c = registration.installing) == null ? void 0 : _c.scriptURL) ?? "";
+}
+async function resolveSwRegisterUrl(options) {
+  const publicPath = window.publicPath;
+  const registrations = await navigator.serviceWorker.getRegistrations();
+  const existingScriptUrls = registrations.map((registration) => getRegistrationScriptUrl(registration)).filter((scriptUrl) => scriptUrl !== "");
+  return resolveSwScriptUrl({
+    publicPath: typeof publicPath === "string" ? publicPath : void 0,
+    existingScriptUrls,
+    version: options.version,
+    pageOrigin: window.location.origin
+  });
+}
+async function removeInvalidRegistrations(keepScriptUrl, log) {
+  const pageOrigin = window.location.origin;
+  const keepUrl = normalizeScriptUrl(keepScriptUrl, pageOrigin);
+  const registrations = await navigator.serviceWorker.getRegistrations();
+  const staleRegistrations = registrations.filter((registration) => {
+    const scriptUrl = getRegistrationScriptUrl(registration);
+    return scriptUrl !== "" && normalizeScriptUrl(scriptUrl, pageOrigin) !== keepUrl && isSameOriginSwScriptUrl(scriptUrl, pageOrigin);
+  });
+  if (staleRegistrations.length === 0) {
+    return;
+  }
+  await Promise.all(staleRegistrations.map((registration) => registration.unregister()));
+  log(`已注销 ${staleRegistrations.length} 个非当前地址的 SW 注册`);
+}
+export {
+  removeInvalidRegistrations,
+  resolveSwRegisterUrl
+};

package/dist/esm/shared/sw-script-url.d.ts

@@ -0,0 +1,42 @@
+/**
+ * SW 注册地址（scriptURL）的构造与解析。
+ *
+ * 注册地址形如 `/sw.js?baseUrl=<CDN 版本目录>&v=<构建版本>`：
+ * - baseUrl：服务端转发层的版本路由参数（nginx location = /sw.js 按
+ *   $arg_baseUrl proxy_pass 到 CDN 版本目录取 sw.js），在线 HTML 由 render
+ *   服务注入 window.publicPath，离线包 HTML 无 publicPath，按设计兜底为
+ *   字面量 'undefined'，由 Native 按 path 命中本地包内 sw.js。
+ * - v：构建版本（RELEASE）。这是离线场景 SW 更新的关键通道——实测
+ *   Chrome 91 WebView 中，register() 携带新 scriptURL 的安装 fetch 会被
+ *   ServiceWorkerClient 拦截并命中 Native 本地包，而 update()/自然软更新
+ *   的 fetch 不经过任何 Java 拦截、直落 nginx（baseUrl=undefined 时 500）。
+ *   因此 scriptURL 必须随构建版本变化：新包的页面以新 URL 注册，经安装
+ *   通道取得新 SW 并接管；同构建重复打开时注册同一 URL，不触发重装。
+ */
+/** 按转发层认识的格式拼 SW 注册地址（含构建版本参数） */
+export declare function buildSwRegisterUrl(baseUrl: string, version: string): string;
+/** 解析注册地址中的构建版本参数；无 v 参数（历史注册）返回 null */
+export declare function getSwScriptVersion(scriptUrl: string, pageOrigin: string): string | null;
+/** 判定注册地址是否为本站 /sw.js（用于历史注册清理的范围判断） */
+export declare function isSameOriginSwScriptUrl(scriptUrl: string, pageOrigin: string): boolean;
+/** 用同一 origin 规范化注册地址，消除绝对/相对形式差异后比较 */
+export declare function normalizeScriptUrl(url: string, pageOrigin: string): string;
+/**
+ * 解析本次应注册的 SW 地址（纯函数，便于单测）：
+ * 1. 在线入口（publicPath 为协议相对或绝对 http(s) URL）：注册
+ *    baseUrl=publicPath 的当前构建地址，保持 nginx 版本转发链路。
+ * 2. 离线入口：若已有同构建版本（v 一致）的本站 /sw.js 注册——无论其
+ *    baseUrl 是 CDN 基址还是 undefined 兜底——原样复用其 scriptURL，
+ *    在线/离线交替打开时不重装、不产生 registration 抖动。
+ * 3. 其余情况（仅旧构建/无 v 历史注册，或无注册）：注册
+ *    baseUrl=undefined 兜底地址 + 当前构建 v。scriptURL 与历史注册不同，
+ *    触发安装 fetch（被 ServiceWorkerClient 拦截、命中 Native 当前包的
+ *    sw.js）完成离线 SW 更新；不回用旧构建的 CDN 基址，避免安装 fetch
+ *    未被拦截时从 CDN 取回旧版本脚本。
+ */
+export declare function resolveSwScriptUrl({ publicPath, existingScriptUrls, version, pageOrigin, }: {
+    publicPath: string | undefined;
+    existingScriptUrls: string[];
+    version: string;
+    pageOrigin: string;
+}): string;

package/dist/esm/shared/sw-script-url.js

@@ -0,0 +1,49 @@
+// src/shared/sw-script-url.ts
+function buildSwRegisterUrl(baseUrl, version) {
+  return `/sw.js?baseUrl=${encodeURIComponent(baseUrl)}&v=${encodeURIComponent(version)}`;
+}
+function getSwScriptVersion(scriptUrl, pageOrigin) {
+  try {
+    return new URL(scriptUrl, pageOrigin).searchParams.get("v");
+  } catch {
+    return null;
+  }
+}
+function isSameOriginSwScriptUrl(scriptUrl, pageOrigin) {
+  try {
+    const url = new URL(scriptUrl, pageOrigin);
+    return url.origin === pageOrigin && url.pathname === "/sw.js";
+  } catch {
+    return false;
+  }
+}
+function normalizeScriptUrl(url, pageOrigin) {
+  try {
+    return new URL(url, pageOrigin).toString();
+  } catch {
+    return url;
+  }
+}
+function resolveSwScriptUrl({
+  publicPath,
+  existingScriptUrls,
+  version,
+  pageOrigin
+}) {
+  if (typeof publicPath === "string" && (publicPath.startsWith("//") || /^https?:\/\//.test(publicPath))) {
+    return buildSwRegisterUrl(publicPath, version);
+  }
+  for (const scriptUrl of existingScriptUrls) {
+    if (isSameOriginSwScriptUrl(scriptUrl, pageOrigin) && getSwScriptVersion(scriptUrl, pageOrigin) === version) {
+      return scriptUrl;
+    }
+  }
+  return buildSwRegisterUrl("undefined", version);
+}
+export {
+  buildSwRegisterUrl,
+  getSwScriptVersion,
+  isSameOriginSwScriptUrl,
+  normalizeScriptUrl,
+  resolveSwScriptUrl
+};

package/dist/esm/sw-cache-validation.d.ts

@@ -0,0 +1,51 @@
+/**
+ * ServiceWorker 资源缓存的响应校验。
+ *
+ * 背景：support 根域源站的 SPA fallback 会对任意路径（含 .js/.css）返回
+ * 200 + text/html 骨架页（响应头含 x-content-type-options: nosniff）。
+ * 当离线包拦截放行（站点禁用 / 包校验失败 / 版本未激活）时，SW 直接落网，
+ * 会把 HTML 响应写入 JS/CSS 缓存；StaleWhileRevalidate 之后先返回坏条目，
+ * 浏览器严格 MIME 检查拒绝执行，触发 ChunkLoadError 白屏（坏条目随后台
+ * revalidate 逐个自愈，表现为间歇性白屏）。
+ * 因此缓存前必须校验响应 MIME 与资源扩展名匹配，并在激活时清理历史坏条目。
+ */
+/**
+ * 资源缓存名前缀。sw.ts 两条路由的 cacheName 必须复用这两个常量构造
+ * （`${PREFIX}${origin}`），否则 activate 清理会因名字漂移静默失效
+ */
+export declare const JS_CSS_CACHE_NAME_PREFIX = "cache-js-css-";
+export declare const STATIC_ASSETS_CACHE_NAME_PREFIX = "cache-static-assets-";
+interface RequestLike {
+    readonly url: string;
+}
+interface ResponseLike {
+    readonly headers: {
+        get(name: string): string | null;
+    };
+}
+export interface CacheLike {
+    keys(): Promise<readonly Request[]>;
+    match(request: Request): Promise<Response | undefined>;
+    delete(request: Request): Promise<boolean>;
+}
+export interface CacheStorageLike {
+    keys(): Promise<string[]>;
+    open(cacheName: string): Promise<CacheLike>;
+}
+/**
+ * 判断响应 MIME 是否与请求 URL 扩展名不匹配（例如 .js 请求拿到 text/html）。
+ * 未知扩展名 / 无法解析的 URL 不校验，维持原有放行行为。
+ */
+export declare function isMimeMismatch(request: RequestLike, response: ResponseLike): boolean;
+export declare class ValidateResponsePlugin {
+    cacheWillUpdate({ request, response }: {
+        request: Request;
+        response: Response;
+    }): Promise<Response | null>;
+}
+/**
+ * 清理历史坏条目：旧版本 SW 可能把源站 HTML 存进了 JS/CSS/静态资源缓存。
+ * 每个坏条目原本要“再白屏一次”才被后台 revalidate 修复，激活时统一清理可立即自愈。
+ */
+export declare function purgeMismatchedCacheEntries(cacheStorage?: CacheStorageLike): Promise<void>;
+export {};

package/dist/esm/sw-cache-validation.js

@@ -0,0 +1,111 @@
+// src/sw-cache-validation.ts
+var JS_MIME_TYPES = [
+  "application/javascript",
+  "text/javascript",
+  "application/x-javascript",
+  "application/ecmascript",
+  "text/ecmascript"
+];
+var STATIC_MIME_RULES = {
+  js: JS_MIME_TYPES,
+  mjs: JS_MIME_TYPES,
+  css: ["text/css"],
+  png: ["image/png"],
+  jpg: ["image/jpeg"],
+  jpeg: ["image/jpeg"],
+  gif: ["image/gif"],
+  webp: ["image/webp"],
+  svg: ["image/svg+xml"],
+  ico: ["image/x-icon", "image/vnd.microsoft.icon"],
+  // 字体除 IANA 新型（font/*，2017 年注册）外，CDN/OSS 常见旧型
+  // application/font-* 与 application/x-font-* 一并放行，避免合法字体
+  // 被误判为不匹配而永远进不了缓存
+  woff: ["font/woff", "application/font-woff", "application/x-font-woff"],
+  woff2: ["font/woff2", "application/font-woff2", "application/x-font-woff2"],
+  ttf: ["font/ttf", "application/font-ttf", "application/x-font-ttf"],
+  otf: ["font/otf", "application/font-otf", "application/x-font-otf"],
+  eot: ["application/vnd.ms-fontobject"]
+};
+var JS_CSS_CACHE_NAME_PREFIX = "cache-js-css-";
+var STATIC_ASSETS_CACHE_NAME_PREFIX = "cache-static-assets-";
+var ASSET_CACHE_NAME_PREFIXES = [
+  JS_CSS_CACHE_NAME_PREFIX,
+  STATIC_ASSETS_CACHE_NAME_PREFIX
+];
+function normalizeMimeType(contentType) {
+  return (contentType ?? "").split(";")[0].trim().toLowerCase();
+}
+function getKnownStaticExtension(url) {
+  let pathname;
+  try {
+    pathname = new URL(url).pathname;
+  } catch {
+    return null;
+  }
+  const lastSegment = pathname.slice(pathname.lastIndexOf("/") + 1);
+  const dotIndex = lastSegment.lastIndexOf(".");
+  if (dotIndex <= 0) {
+    return null;
+  }
+  const extension = lastSegment.slice(dotIndex + 1).toLowerCase();
+  return Object.prototype.hasOwnProperty.call(STATIC_MIME_RULES, extension) ? extension : null;
+}
+function isMimeMismatch(request, response) {
+  const extension = getKnownStaticExtension(request.url);
+  if (!extension) {
+    return false;
+  }
+  const mimeType = normalizeMimeType(response.headers.get("content-type"));
+  if (!mimeType) {
+    return true;
+  }
+  return !STATIC_MIME_RULES[extension].includes(mimeType);
+}
+var ValidateResponsePlugin = class {
+  async cacheWillUpdate({ request, response }) {
+    if (!response) {
+      console.warn("不缓存失败的响应", request.url, "No Response");
+      return null;
+    }
+    if (response.status === 0) {
+      return response;
+    }
+    if (!response.ok) {
+      console.warn("不缓存失败的响应", request.url, response.status);
+      return null;
+    }
+    if (isMimeMismatch(request, response)) {
+      console.warn(
+        "MIME 类型与资源扩展名不匹配，不缓存",
+        request.url,
+        response.headers.get("content-type")
+      );
+      return null;
+    }
+    return response;
+  }
+};
+async function purgeMismatchedCacheEntries(cacheStorage = caches) {
+  const cacheNames = await cacheStorage.keys();
+  const assetCacheNames = cacheNames.filter(
+    (name) => ASSET_CACHE_NAME_PREFIXES.some((prefix) => name.startsWith(prefix))
+  );
+  for (const cacheName of assetCacheNames) {
+    const cache = await cacheStorage.open(cacheName);
+    const requests = await cache.keys();
+    for (const request of requests) {
+      const cachedResponse = await cache.match(request);
+      if (cachedResponse && isMimeMismatch(request, cachedResponse)) {
+        await cache.delete(request);
+        console.warn("[ServiceWorker] 清理 MIME 不匹配的缓存条目", cacheName, request.url);
+      }
+    }
+  }
+}
+export {
+  JS_CSS_CACHE_NAME_PREFIX,
+  STATIC_ASSETS_CACHE_NAME_PREFIX,
+  ValidateResponsePlugin,
+  isMimeMismatch,
+  purgeMismatchedCacheEntries
+};

package/dist/esm/sw-chunk-diagnostics.d.ts

@@ -0,0 +1,19 @@
+import type { CachedResponseWillBeUsedCallbackParam, FetchDidFailCallbackParam, FetchDidSucceedCallbackParam, HandlerDidCompleteCallbackParam, HandlerDidRespondCallbackParam, HandlerWillStartCallbackParam, RequestWillFetchCallbackParam, WorkboxPlugin } from 'workbox-core/types';
+/**
+ * 仅观察 script/style 的原始 SWR 请求。state 由 Workbox 为每个 handler
+ * 单独创建；不要把请求状态挂到共享 plugin 实例上。
+ */
+export declare class ChunkDiagnosticsPlugin implements WorkboxPlugin {
+    private readonly options;
+    constructor(options: {
+        release: string;
+    });
+    handlerWillStart({ request, state }: HandlerWillStartCallbackParam): Promise<void>;
+    requestWillFetch({ request, state }: RequestWillFetchCallbackParam): Promise<Request>;
+    cachedResponseWillBeUsed({ cachedResponse, state }: CachedResponseWillBeUsedCallbackParam): Promise<Response | undefined>;
+    fetchDidSucceed({ response, state }: FetchDidSucceedCallbackParam): Promise<Response>;
+    fetchDidFail({ error, state }: FetchDidFailCallbackParam): Promise<void>;
+    handlerDidRespond(options: HandlerDidRespondCallbackParam): Promise<void>;
+    handlerDidComplete(options: HandlerDidCompleteCallbackParam): Promise<void>;
+    private report;
+}

package/dist/esm/sw-chunk-diagnostics.js

@@ -0,0 +1,124 @@
+// src/sw-chunk-diagnostics.ts
+import {
+  CHUNK_TRACE_MESSAGE,
+  createChunkDiagnosticId,
+  sanitizeChunkUrl
+} from "./shared/chunk-diagnostics";
+function safeErrorName(error) {
+  return /^(Error|TypeError|RangeError|AbortError|NetworkError|TimeoutError|SecurityError|InvalidStateError|QuotaExceededError|no-response)$/.test(
+    error.name
+  ) ? error.name : "Error";
+}
+function responseMime(response) {
+  return (response.headers.get("content-type") || "").split(";", 1)[0].trim();
+}
+var ChunkDiagnosticsPlugin = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async handlerWillStart({ request, state }) {
+    try {
+      if (!state || request.destination !== "script" && request.destination !== "style") {
+        return;
+      }
+      state.trace = {
+        requestId: createChunkDiagnosticId(),
+        at: Date.now(),
+        resource: sanitizeChunkUrl(request.url),
+        phase: "response",
+        destination: request.destination,
+        mode: request.mode,
+        credentials: request.credentials,
+        cache: "unknown",
+        network: "pending",
+        swRelease: this.options.release
+      };
+    } catch {
+    }
+  }
+  async requestWillFetch({ request, state }) {
+    try {
+      const trace = state == null ? void 0 : state.trace;
+      if (trace) {
+        trace.mode = request.mode;
+        trace.credentials = request.credentials;
+      }
+    } catch {
+    }
+    return request;
+  }
+  async cachedResponseWillBeUsed({ cachedResponse, state }) {
+    try {
+      const trace = state == null ? void 0 : state.trace;
+      if (trace)
+        trace.cache = cachedResponse ? "hit" : "miss";
+    } catch {
+    }
+    return cachedResponse;
+  }
+  async fetchDidSucceed({ response, state }) {
+    try {
+      const trace = state == null ? void 0 : state.trace;
+      if (trace) {
+        trace.network = "response";
+        trace.networkStatus = response.status;
+        trace.networkType = response.type;
+        trace.networkMime = responseMime(response);
+      }
+    } catch {
+    }
+    return response;
+  }
+  async fetchDidFail({ error, state }) {
+    try {
+      const trace = state == null ? void 0 : state.trace;
+      if (trace) {
+        trace.network = "error";
+        trace.errorName = safeErrorName(error);
+      }
+    } catch {
+    }
+  }
+  async handlerDidRespond(options) {
+    this.report(options, "response");
+  }
+  async handlerDidComplete(options) {
+    this.report(options, "complete");
+  }
+  report({ event, response, state }, phase) {
+    try {
+      const diagnostic = state;
+      const trace = diagnostic == null ? void 0 : diagnostic.trace;
+      const sentKey = phase === "response" ? "responseSent" : "completeSent";
+      if (!diagnostic || !trace || diagnostic[sentKey])
+        return;
+      diagnostic[sentKey] = true;
+      const snapshot = {
+        ...trace,
+        phase,
+        ...phase === "complete" ? { completedAt: Date.now() } : {},
+        servedFrom: response ? trace.cache === "hit" ? "cache" : "network" : "none",
+        ...response ? {
+          responseStatus: response.status,
+          responseType: response.type,
+          responseMime: responseMime(response)
+        } : {}
+      };
+      const clientId = event.clientId;
+      if (!clientId)
+        return;
+      const delivery = (async () => {
+        try {
+          const client = await self.clients.get(clientId);
+          client == null ? void 0 : client.postMessage({ type: CHUNK_TRACE_MESSAGE, payload: snapshot });
+        } catch {
+        }
+      })();
+      event.waitUntil(delivery);
+    } catch {
+    }
+  }
+};
+export {
+  ChunkDiagnosticsPlugin
+};