HTML that survives the network.

offline-research/
├── offline-first-research.html      # portable, self-contained edition
└── web/
    ├── index.html                   # installed application shell
    ├── manifest.webmanifest
    ├── sw.js
    ├── package-manifest.json        # asset URLs, versions, hashes
    ├── assets/
    │   ├── application.css
    │   ├── application.js
    │   ├── icons/
    │   └── diagrams/
    └── content/
        ├── report-v1.json
        └── search-v1.json

const CACHE_VERSION = "offline-report-v1";
const REQUIRED_ASSETS = [
  "/",
  "/index.html",
  "/assets/application.css",
  "/assets/application.js",
  "/content/report-v1.json",
  "/content/search-v1.json",
  "/icons/icon-192.png",
  "/icons/icon-512.png"
];

self.addEventListener("install", (event) => {
  event.waitUntil(
    caches.open(CACHE_VERSION)
      .then((cache) => cache.addAll(REQUIRED_ASSETS))
  );
});

self.addEventListener("activate", (event) => {
  event.waitUntil(
    caches.keys().then((keys) =>
      Promise.all(
        keys
          .filter((key) => key !== CACHE_VERSION)
          .map((key) => caches.delete(key))
      )
    )
  );
});

self.addEventListener("fetch", (event) => {
  const request = event.request;

  if (request.mode === "navigate") {
    event.respondWith(
      caches.match("/index.html")
        .then((cached) => cached ?? fetch(request))
    );
    return;
  }

  event.respondWith(
    caches.match(request)
      .then((cached) => cached ?? fetch(request))
  );
});

async function provisionOfflinePackage(
  version: string,
  requiredAssets: readonly string[]
): Promise<{
  persistent: boolean;
  usage?: number;
  quota?: number;
}> {
  const persistent =
    "storage" in navigator &&
    "persist" in navigator.storage
      ? await navigator.storage.persist()
      : false;

  const cache = await caches.open(version);
  await cache.addAll(requiredAssets);

  const missing: string[] = [];
  for (const url of requiredAssets) {
    if (!(await cache.match(url))) {
      missing.push(url);
    }
  }

  if (missing.length > 0) {
    await caches.delete(version);
    throw new Error(
      `Offline package incomplete: ${missing.join(", ")}`
    );
  }

  const estimate = await navigator.storage?.estimate();

  return {
    persistent,
    usage: estimate?.usage,
    quota: estimate?.quota
  };
}

interface PendingOperation {
  id: string;                 // idempotency key
  entityId: string;
  baseVersion: string;        // conflict detection
  operation: "create" | "update" | "delete";
  payload: unknown;
  createdAt: string;
  attempts: number;
  state:
    | "pending"
    | "sending"
    | "conflict"
    | "acknowledged";
}