@kestack/web-platform 0.0.0-stage → 0.0.0

package/src/pwa/worker/global-scope/global-scope.ts

@@ -0,0 +1,99 @@
+import * as Context from 'effect/Context';
+import * as Effect from 'effect/Effect';
+import * as Fiber from 'effect/Fiber';
+
+/** The parts of `ServiceWorkerGlobalScope` the runtime touches; tests pass a fake. */
+export type ServiceWorkerGlobal = Pick<
+  ServiceWorkerGlobalScope,
+  | 'addEventListener'
+  | 'caches'
+  | 'clients'
+  | 'fetch'
+  | 'location'
+  | 'registration'
+  | 'skipWaiting'
+>;
+
+interface GlobalScopeService {
+  readonly origin: string;
+  readonly caches: CacheStorage;
+  readonly fetch: (
+    input: RequestInfo | URL,
+    init?: RequestInit,
+  ) => Promise<Response>;
+  readonly skipWaiting: () => Promise<void>;
+  readonly claimClients: () => Promise<void>;
+  /** Whether an older version is active, i.e. this is not the first install. */
+  readonly hasActiveWorker: () => boolean;
+  /** Whether a newer version has installed and waits to be accepted. */
+  readonly hasWaitingWorker: () => boolean;
+}
+
+/** The service worker's global scope, as seen by the runtime. */
+export class GlobalScope extends Context.Service<
+  GlobalScope,
+  GlobalScopeService
+>()('@kestack/web-platform/pwa/worker/GlobalScope') {
+  static fromGlobal(global: ServiceWorkerGlobal): GlobalScopeService {
+    return {
+      origin: global.location.origin,
+      caches: global.caches,
+      fetch: (input, init) => global.fetch(input, init),
+      skipWaiting: () => global.skipWaiting(),
+      claimClients: () => global.clients.claim(),
+      hasActiveWorker: () => global.registration.active !== null,
+      hasWaitingWorker: () => global.registration.waiting !== null,
+    };
+  }
+}
+
+/** Keeps the worker alive until a detached fiber (background cache work) ends. */
+export class KeepAlive extends Context.Service<
+  KeepAlive,
+  (fiber: Fiber.Fiber<unknown, unknown>) => void
+>()('@kestack/web-platform/pwa/worker/KeepAlive') {
+  static forEvent(
+    event: ExtendableEvent,
+  ): (fiber: Fiber.Fiber<unknown, unknown>) => void {
+    return (fiber) =>
+      event.waitUntil(Effect.runPromise(Fiber.join(fiber).pipe(Effect.ignore)));
+  }
+}
+
+const toError = (cause: unknown): Error =>
+  cause instanceof Error ? cause : new Error(String(cause));
+
+/** A promise-returning platform call as an Effect failing with `Error`. */
+export const attempt = <A>(
+  evaluate: () => PromiseLike<A>,
+): Effect.Effect<A, Error> =>
+  Effect.tryPromise({ try: evaluate, catch: toError });
+
+export const openCache = (
+  name: string,
+): Effect.Effect<Cache, Error, GlobalScope> =>
+  Effect.flatMap(GlobalScope, (scope) =>
+    attempt(() => scope.caches.open(name)),
+  );
+
+export const fetchNetwork = (
+  input: Request | string,
+  init?: RequestInit,
+): Effect.Effect<Response, Error, GlobalScope> =>
+  Effect.flatMap(GlobalScope, (scope) =>
+    attempt(() => scope.fetch(input, init)),
+  );
+
+/** Deletes every cache whose name satisfies `predicate`. */
+export const deleteCaches = (
+  predicate: (name: string) => boolean,
+): Effect.Effect<void, Error, GlobalScope> =>
+  Effect.gen(function* () {
+    const scope = yield* GlobalScope;
+    const names = yield* attempt(() => scope.caches.keys());
+    yield* Effect.forEach(
+      names.filter(predicate),
+      (name) => attempt(() => scope.caches.delete(name)),
+      { discard: true, concurrency: 'unbounded' },
+    );
+  });

package/src/pwa/worker/global-scope/index.ts

@@ -0,0 +1,9 @@
+export {
+  attempt,
+  deleteCaches,
+  fetchNetwork,
+  GlobalScope,
+  KeepAlive,
+  openCache,
+  type ServiceWorkerGlobal,
+} from './global-scope.js';

package/src/pwa/worker/index.ts

@@ -0,0 +1 @@
+export { runServiceWorker, WorkerHost } from './worker.js';

package/src/pwa/worker/lifecycle/index.ts

@@ -0,0 +1 @@
+export { onActivate, onInstall } from './lifecycle.js';

package/src/pwa/worker/lifecycle/lifecycle.ts

@@ -0,0 +1,52 @@
+import * as Effect from 'effect/Effect';
+import {
+  type BuildId,
+  isRuntimeCacheName,
+  pagesCacheName,
+  runtimeCacheName,
+} from '../../shared/build/index.js';
+import type {
+  WorkerBuildInfo,
+  WorkerConfig,
+} from '../../shared/config/index.js';
+import { attempt, deleteCaches, GlobalScope } from '../global-scope/index.js';
+import { deleteOtherPrecaches, installPrecache } from '../precache/index.js';
+
+/**
+ * Saves the Precache. The first install (no older version active) then skips
+ * waiting so the first visit is controlled; later versions wait for
+ * SKIP_WAITING from the Update Prompt.
+ */
+export const onInstall = (
+  info: WorkerBuildInfo,
+): Effect.Effect<void, Error, GlobalScope> =>
+  Effect.gen(function* () {
+    const scope = yield* GlobalScope;
+    const firstInstall = !scope.hasActiveWorker();
+    yield* installPrecache(info);
+    if (firstInstall) yield* attempt(() => scope.skipWaiting());
+  });
+
+/**
+ * Deletes other builds' Precaches, other builds' saved pages, and Runtime
+ * Caches no rule uses any more, then takes control of every open page.
+ */
+export const onActivate = (
+  info: WorkerBuildInfo,
+): Effect.Effect<void, Error, GlobalScope> =>
+  Effect.gen(function* () {
+    const scope = yield* GlobalScope;
+    const kept = keptRuntimeCaches(info.buildId, info.config);
+    yield* deleteOtherPrecaches(info.buildId);
+    yield* deleteCaches((name) => isRuntimeCacheName(name) && !kept.has(name));
+    yield* attempt(() => scope.claimClients());
+  });
+
+const keptRuntimeCaches = (
+  buildId: BuildId,
+  config: WorkerConfig,
+): ReadonlySet<string> =>
+  new Set([
+    ...config.strategies.map((rule) => runtimeCacheName(rule.cacheName)),
+    ...(config.navigation.cachePages ? [pagesCacheName(buildId)] : []),
+  ]);

package/src/pwa/worker/messages/index.ts

@@ -0,0 +1 @@
+export { makeMessageHub } from './messages.js';

package/src/pwa/worker/messages/messages.ts

@@ -0,0 +1,67 @@
+import * as Effect from 'effect/Effect';
+import * as Queue from 'effect/Queue';
+import * as Stream from 'effect/Stream';
+
+/**
+ * How long a message event is held open after it reaches a subscriber, so
+ * the subscriber can still call `event.waitUntil` asynchronously (the
+ * platform only allows that while another lifetime promise is pending).
+ */
+const GRACE_MS = 100;
+
+interface Pending {
+  readonly event: ExtendableMessageEvent;
+  readonly release: () => void;
+}
+
+/**
+ * Non-Control-Channel message events for `WorkerHost.messages`. Until the
+ * first subscriber arrives, events are buffered and the worker is kept
+ * alive; `close()` releases them when no subscriber will ever come.
+ */
+export const makeMessageHub = (options: { readonly buffer: boolean }) => {
+  let pending: Array<Pending> = [];
+  let open = options.buffer;
+  const subscribers = new Set<(event: ExtendableMessageEvent) => void>();
+
+  const hold = (event: ExtendableMessageEvent): (() => void) => {
+    let release = () => {};
+    event.waitUntil(new Promise<void>((resolve) => (release = resolve)));
+    return () => setTimeout(release, GRACE_MS);
+  };
+
+  const deliver = (event: ExtendableMessageEvent, release: () => void) => {
+    for (const subscriber of subscribers) subscriber(event);
+    release();
+  };
+
+  const publish = (event: ExtendableMessageEvent): void => {
+    if (subscribers.size > 0) deliver(event, hold(event));
+    else if (open) pending.push({ event, release: hold(event) });
+  };
+
+  const close = (): void => {
+    open = false;
+    for (const { release } of pending) release();
+    pending = [];
+  };
+
+  const messages: Stream.Stream<ExtendableMessageEvent> = Stream.callback(
+    (queue) =>
+      Effect.acquireRelease(
+        Effect.sync(() => {
+          const subscriber = (event: ExtendableMessageEvent) => {
+            Queue.offerUnsafe(queue, event);
+          };
+          subscribers.add(subscriber);
+          const buffered = pending;
+          pending = [];
+          for (const { event, release } of buffered) deliver(event, release);
+          return subscriber;
+        }),
+        (subscriber) => Effect.sync(() => subscribers.delete(subscriber)),
+      ),
+  );
+
+  return { publish, close, messages };
+};

package/src/pwa/worker/precache/download.ts

@@ -0,0 +1,38 @@
+import * as Effect from 'effect/Effect';
+import {
+  attempt,
+  fetchNetwork,
+  type GlobalScope,
+} from '../global-scope/index.js';
+
+/**
+ * Saves one entry unless the cache already holds it (a retried install of
+ * the same build). Bypasses the HTTP cache so a stale file is never saved.
+ */
+export const downloadEntry = (
+  cache: Cache,
+  url: string,
+): Effect.Effect<void, Error, GlobalScope> =>
+  Effect.gen(function* () {
+    if ((yield* attempt(() => cache.match(url))) !== undefined) return;
+    const response = yield* fetchNetwork(url, { cache: 'reload' });
+    if (!response.ok) {
+      return yield* Effect.fail(
+        new Error(`Precache download failed: ${url} (${response.status})`),
+      );
+    }
+    yield* attempt(() => cache.put(url, withoutRedirect(response)));
+  });
+
+/**
+ * Browsers refuse a redirected response for a navigation, and the App Shell
+ * and Offline Fallback answer navigations, so store a fresh copy.
+ */
+const withoutRedirect = (response: Response): Response =>
+  response.redirected
+    ? new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+      })
+    : response;

package/src/pwa/worker/precache/index.ts

@@ -0,0 +1,7 @@
+export {
+  deleteOtherPrecaches,
+  installPrecache,
+  matchPrecache,
+  precachedUrls,
+  servePrecached,
+} from './precache.js';

package/src/pwa/worker/precache/precache.ts

@@ -0,0 +1,72 @@
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import {
+  type BuildId,
+  isPrecacheCacheName,
+  precacheCacheName,
+} from '../../shared/build/index.js';
+import type { WorkerBuildInfo } from '../../shared/config/index.js';
+import {
+  attempt,
+  deleteCaches,
+  fetchNetwork,
+  GlobalScope,
+  openCache,
+} from '../global-scope/index.js';
+import { downloadEntry } from './download.js';
+
+/** Downloads every Precache entry into this build's cache; any failure fails install. */
+export const installPrecache = (
+  info: WorkerBuildInfo,
+): Effect.Effect<void, Error, GlobalScope> =>
+  Effect.gen(function* () {
+    const scope = yield* GlobalScope;
+    const cache = yield* openCache(precacheCacheName(info.buildId));
+    yield* Effect.forEach(
+      info.precache,
+      (entry) => downloadEntry(cache, new URL(entry.url, scope.origin).href),
+      { discard: true, concurrency: 8 },
+    );
+  });
+
+/** Absolute URLs of every Precache entry, for synchronous routing. */
+export const precachedUrls = (
+  info: WorkerBuildInfo,
+  origin: string,
+): ReadonlySet<string> =>
+  new Set(info.precache.map((entry) => new URL(entry.url, origin).href));
+
+/** The precached response for an origin-relative or absolute URL. */
+export const matchPrecache = (
+  buildId: BuildId,
+  url: string,
+): Effect.Effect<Option.Option<Response>, never, GlobalScope> =>
+  Effect.gen(function* () {
+    const scope = yield* GlobalScope;
+    const cache = yield* openCache(precacheCacheName(buildId));
+    const hit = yield* attempt(() =>
+      cache.match(new URL(url, scope.origin).href),
+    );
+    return Option.fromNullishOr(hit);
+  }).pipe(Effect.orElseSucceed(() => Option.none<Response>()));
+
+/** Cache-first from the Precache; the network only if the entry is missing. */
+export const servePrecached = (
+  buildId: BuildId,
+  request: Request,
+): Effect.Effect<Response, Error, GlobalScope> =>
+  Effect.flatMap(
+    matchPrecache(buildId, request.url),
+    Option.match({
+      onNone: () => fetchNetwork(request),
+      onSome: Effect.succeed,
+    }),
+  );
+
+/** Deletes every other build's Precache. */
+export const deleteOtherPrecaches = (
+  buildId: BuildId,
+): Effect.Effect<void, Error, GlobalScope> =>
+  deleteCaches(
+    (name) => isPrecacheCacheName(name) && name !== precacheCacheName(buildId),
+  );

package/src/pwa/worker/requests/index.ts

@@ -0,0 +1 @@
+export { makeFetchRouter } from './requests.js';

package/src/pwa/worker/requests/pages/index.ts

@@ -0,0 +1 @@
+export { handleNavigation, isHandledNavigation } from './pages.js';

package/src/pwa/worker/requests/pages/pages.ts

@@ -0,0 +1,116 @@
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import { type BuildId, pagesCacheName } from '../../../shared/build/index.js';
+import type { WorkerBuildInfo } from '../../../shared/config/index.js';
+import {
+  attempt,
+  fetchNetwork,
+  GlobalScope,
+  type KeepAlive,
+  openCache,
+} from '../../global-scope/index.js';
+import { networkFirst } from '../strategies/index.js';
+import { matchPrecache } from '../../precache/index.js';
+
+/** Whether the worker answers this navigation; denylisted paths go straight to the network. */
+export const isHandledNavigation = (
+  info: WorkerBuildInfo,
+  request: Request,
+  origin: string,
+): boolean => {
+  const url = new URL(request.url);
+  return (
+    request.mode === 'navigate' &&
+    url.origin === origin &&
+    !info.config.navigation.denylist.some((prefix) =>
+      url.pathname.startsWith(prefix),
+    )
+  );
+};
+
+/**
+ * Network within `networkTimeoutMs`; then the saved page (only with
+ * `cachePages`), the App Shell (with `shell`), and the Offline Fallback.
+ * The Offline Fallback is reached through a redirect to
+ * `${offlineFallback}?from=<path+search>`, so a client router renders the
+ * fallback route instead of the requested one; a request already for the
+ * fallback path gets its body directly.
+ *
+ * While a newer version waits to be accepted, the network holds that newer
+ * build's HTML, so with `shell` the App Shell of this build answers first:
+ * every page stays on the active Build ID until the update is accepted.
+ * For the same reason, pages are not saved while a newer version waits:
+ * they belong to that build, not to this Build ID's pages cache.
+ */
+export const handleNavigation = (
+  info: WorkerBuildInfo,
+  request: Request,
+): Effect.Effect<Response, Error, GlobalScope | KeepAlive> => {
+  const { navigation } = info.config;
+  const shell = matchPrecache(info.buildId, navigation.shellPath);
+  const network = navigation.cachePages
+    ? Effect.tap(fetchNetwork(request), (response) =>
+        response.ok
+          ? savePage(info.buildId, request, response.clone())
+          : Effect.void,
+      )
+    : fetchNetwork(request);
+  const networkFirstNavigation = networkFirst({
+    network,
+    fallback: firstSome([
+      ...(navigation.cachePages ? [matchPage(info.buildId, request)] : []),
+      ...(navigation.shell ? [shell] : []),
+      offlineFallback(info, request),
+    ]),
+    timeoutMs: navigation.networkTimeoutMs,
+  });
+  if (!navigation.shell) return networkFirstNavigation;
+  return Effect.gen(function* () {
+    const scope = yield* GlobalScope;
+    if (scope.hasWaitingWorker()) {
+      const pinned = yield* shell;
+      if (Option.isSome(pinned)) return pinned.value;
+    }
+    return yield* networkFirstNavigation;
+  });
+};
+
+const offlineFallback = (info: WorkerBuildInfo, request: Request) => {
+  const path = info.config.navigation.offlineFallback;
+  const url = new URL(request.url);
+  const fallback = matchPrecache(info.buildId, path);
+  if (url.pathname === path) return fallback;
+  const target = new URL(path, url.origin);
+  target.searchParams.set('from', url.pathname + url.search);
+  return Effect.map(
+    fallback,
+    Option.map(() => Response.redirect(target.href, 302)),
+  );
+};
+
+const savePage = (buildId: BuildId, request: Request, response: Response) =>
+  Effect.gen(function* () {
+    const scope = yield* GlobalScope;
+    if (scope.hasWaitingWorker()) return;
+    const cache = yield* openCache(pagesCacheName(buildId));
+    yield* attempt(() => cache.put(request, response));
+  }).pipe(Effect.ignore);
+
+const matchPage = (buildId: BuildId, request: Request) =>
+  Effect.flatMap(openCache(pagesCacheName(buildId)), (cache) =>
+    attempt(() => cache.match(request)),
+  ).pipe(
+    Effect.map(Option.fromNullishOr),
+    Effect.orElseSucceed(() => Option.none<Response>()),
+  );
+
+const firstSome = <R>(
+  candidates: ReadonlyArray<Effect.Effect<Option.Option<Response>, never, R>>,
+): Effect.Effect<Option.Option<Response>, never, R> =>
+  Effect.gen(function* () {
+    for (const candidate of candidates) {
+      const hit = yield* candidate;
+      if (Option.isSome(hit)) return hit;
+    }
+    return Option.none();
+  });

package/src/pwa/worker/requests/requests.ts

@@ -0,0 +1,39 @@
+import type * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import type { WorkerBuildInfo } from '../../shared/config/index.js';
+import { isNeverCached } from '../../shared/strategy/index.js';
+import type { GlobalScope, KeepAlive } from '../global-scope/index.js';
+import { handleNavigation, isHandledNavigation } from './pages/index.js';
+import { precachedUrls, servePrecached } from '../precache/index.js';
+import { handleRuntimeCache } from './strategies/index.js';
+
+type Handler = Effect.Effect<Response, Error, GlobalScope | KeepAlive>;
+
+/**
+ * Decides synchronously (so `respondWith` can be called in time) who answers
+ * a request. None means the browser fetches it as if there were no worker.
+ * Order: only GET over http(s); `neverCache` bypasses everything;
+ * navigations; Precache entries; Runtime Cache rules.
+ */
+export const makeFetchRouter = (info: WorkerBuildInfo, origin: string) => {
+  const precached = precachedUrls(info, origin);
+  return (request: Request): Option.Option<Handler> => {
+    const url = new URL(request.url);
+    if (request.method !== 'GET' || !url.protocol.startsWith('http')) {
+      return Option.none();
+    }
+    if (isNeverCached(info.config.neverCache, request, origin)) {
+      return Option.none();
+    }
+    if (request.mode === 'navigate') {
+      return isHandledNavigation(info, request, origin)
+        ? Option.some(handleNavigation(info, request))
+        : Option.none();
+    }
+    url.hash = '';
+    if (precached.has(url.href)) {
+      return Option.some(servePrecached(info.buildId, request));
+    }
+    return handleRuntimeCache(info.config, request, origin);
+  };
+};

package/src/pwa/worker/requests/strategies/cache-store.ts

@@ -0,0 +1,82 @@
+import * as Clock from 'effect/Clock';
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import {
+  attempt,
+  type GlobalScope,
+  openCache,
+} from '../../global-scope/index.js';
+
+const CACHED_AT_HEADER = 'x-pwa-toolkit-cached-at';
+
+/** One Runtime Cache with its expiry limits. */
+export interface CacheStore {
+  /** A fresh saved response; expired ones are deleted and count as a miss. */
+  readonly match: (
+    request: Request,
+  ) => Effect.Effect<Option.Option<Response>, never, GlobalScope>;
+  /** Saves a cacheable response, then trims to `maxEntries` (oldest first). */
+  readonly put: (
+    request: Request,
+    response: Response,
+  ) => Effect.Effect<void, never, GlobalScope>;
+}
+
+export const cacheStore = (options: {
+  readonly name: string;
+  readonly maxEntries: number | undefined;
+  readonly maxAgeSeconds: number | undefined;
+}): CacheStore => ({
+  match: (request) =>
+    Effect.gen(function* () {
+      const cache = yield* openCache(options.name);
+      const hit = yield* attempt(() => cache.match(request));
+      if (hit === undefined) return Option.none();
+      if (options.maxAgeSeconds !== undefined) {
+        const cachedAt = Number(hit.headers.get(CACHED_AT_HEADER));
+        const now = yield* Clock.currentTimeMillis;
+        if (cachedAt > 0 && now - cachedAt > options.maxAgeSeconds * 1000) {
+          yield* attempt(() => cache.delete(request));
+          return Option.none();
+        }
+      }
+      return Option.some(hit);
+    }).pipe(Effect.orElseSucceed(() => Option.none<Response>())),
+  put: (request, response) =>
+    Effect.gen(function* () {
+      if (!isCacheable(response)) return;
+      const cache = yield* openCache(options.name);
+      const now = yield* Clock.currentTimeMillis;
+      yield* attempt(() => cache.put(request, stamped(response, now)));
+      if (options.maxEntries !== undefined) {
+        const keys = yield* attempt(() => cache.keys());
+        const excess = keys.slice(
+          0,
+          Math.max(0, keys.length - options.maxEntries),
+        );
+        yield* Effect.forEach(
+          excess,
+          (key) => attempt(() => cache.delete(key)),
+          {
+            discard: true,
+          },
+        );
+      }
+    }).pipe(Effect.ignore),
+});
+
+/** Successful responses, and opaque cross-origin ones (their status is hidden). */
+const isCacheable = (response: Response): boolean =>
+  response.status === 200 || response.type === 'opaque';
+
+/** Opaque responses cannot be rebuilt, so they are stored unstamped and never age out. */
+const stamped = (response: Response, now: number): Response => {
+  if (response.type === 'opaque') return response;
+  const headers = new Headers(response.headers);
+  headers.set(CACHED_AT_HEADER, String(now));
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers,
+  });
+};

package/src/pwa/worker/requests/strategies/index.ts

@@ -0,0 +1,2 @@
+export { clearRuntimeCaches, handleRuntimeCache } from './strategies.js';
+export { networkFirst } from './network-first.js';

package/src/pwa/worker/requests/strategies/kinds.ts

@@ -0,0 +1,63 @@
+import * as Effect from 'effect/Effect';
+import * as Option from 'effect/Option';
+import type { StrategyName } from '../../../shared/strategy/index.js';
+import {
+  fetchNetwork,
+  type GlobalScope,
+  KeepAlive,
+} from '../../global-scope/index.js';
+import { networkFirst } from './network-first.js';
+import type { CacheStore } from './cache-store.js';
+
+type Strategy = (
+  request: Request,
+  store: CacheStore,
+  networkTimeoutMs: number | undefined,
+) => Effect.Effect<Response, Error, GlobalScope | KeepAlive>;
+
+/** Fetches and saves a copy; the caller gets the original. */
+const fetchAndSave = (request: Request, store: CacheStore) =>
+  Effect.tap(fetchNetwork(request), (response) =>
+    store.put(request, response.clone()),
+  );
+
+const missing = (request: Request) =>
+  new Error(`Not in the Runtime Cache: ${request.url}`);
+
+export const strategies: Record<StrategyName, Strategy> = {
+  'network-first': (request, store, networkTimeoutMs) =>
+    networkFirst({
+      network: fetchAndSave(request, store),
+      fallback: store.match(request),
+      timeoutMs: networkTimeoutMs,
+    }),
+
+  'cache-first': (request, store) =>
+    Effect.flatMap(
+      store.match(request),
+      Option.match({
+        onNone: () => fetchAndSave(request, store),
+        onSome: Effect.succeed,
+      }),
+    ),
+
+  'stale-while-revalidate': (request, store) =>
+    Effect.gen(function* () {
+      const cached = yield* store.match(request);
+      if (Option.isNone(cached)) return yield* fetchAndSave(request, store);
+      const revalidate = yield* Effect.forkDetach(fetchAndSave(request, store));
+      (yield* KeepAlive)(revalidate);
+      return cached.value;
+    }),
+
+  'network-only': (request) => fetchNetwork(request),
+
+  'cache-only': (request, store) =>
+    Effect.flatMap(
+      store.match(request),
+      Option.match({
+        onNone: () => Effect.fail(missing(request)),
+        onSome: Effect.succeed,
+      }),
+    ),
+};