@kestack/web-platform 0.0.0-stage → 0.0.1

package/dist/pwa/extras/storage/storage.js

@@ -0,0 +1,51 @@
+import { lazyService } from "../lazy-service/lazy-service.js";
+import { useEffect, useMemo, useState } from "react";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Option from "effect/Option";
+//#region src/pwa/extras/storage/storage.ts
+const storage = () => typeof navigator !== "undefined" && navigator.storage !== void 0 ? Option.some(navigator.storage) : Option.none();
+const call = (method) => Effect.suspend(() => Option.match(Option.filter(storage(), (s) => typeof s[method] === "function"), {
+	onNone: () => Effect.succeed(Option.none()),
+	onSome: (s) => Effect.tryPromise(() => s[method]()).pipe(Effect.map(Option.some), Effect.orElseSucceed(Option.none))
+}));
+/** Persistent storage and usage. Every member is none where the Storage API is missing. */
+var StoragePersistence = class extends Context.Service()("@kestack/web-platform/pwa/StoragePersistence") {
+	static layer = Layer.succeed(this, {
+		persisted: call("persisted"),
+		persist: call("persist"),
+		estimate: call("estimate").pipe(Effect.map(Option.map((estimate) => ({
+			usage: estimate.usage ?? 0,
+			quota: estimate.quota ?? 0
+		}))))
+	});
+};
+const useStorageService = lazyService(StoragePersistence, StoragePersistence.layer);
+const runOr = (effect, fallback) => effect === void 0 ? Promise.resolve(fallback) : Effect.runPromise(effect);
+/** `null` while unknown or where the Storage API is missing. */
+const useStoragePersistence = () => {
+	const service = useStorageService();
+	const [persisted, setPersisted] = useState(null);
+	useEffect(() => {
+		if (service === void 0) return;
+		let mounted = true;
+		Effect.runPromise(service.persisted).then((value) => mounted && setPersisted(Option.getOrNull(value)));
+		return () => {
+			mounted = false;
+		};
+	}, [service]);
+	return useMemo(() => ({
+		persisted,
+		persist: async () => {
+			const value = Option.getOrNull(await runOr(service?.persist, Option.none()));
+			setPersisted(value);
+			return value;
+		},
+		estimate: async () => Option.getOrNull(await runOr(service?.estimate, Option.none()))
+	}), [persisted, service]);
+};
+//#endregion
+export { StoragePersistence, useStoragePersistence };
+
+//# sourceMappingURL=storage.js.map

package/dist/pwa/extras/storage/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage.js","names":[],"sources":["../../../../src/pwa/extras/storage/storage.ts"],"sourcesContent":["import * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport * as Option from 'effect/Option';\nimport { useEffect, useMemo, useState } from 'react';\nimport { lazyService } from '../lazy-service/index.js';\n\nconst storage = (): Option.Option<StorageManager> =>\n  typeof navigator !== 'undefined' && navigator.storage !== undefined\n    ? Option.some(navigator.storage)\n    : Option.none();\n\nconst call = <K extends 'persisted' | 'persist' | 'estimate'>(\n  method: K,\n): Effect.Effect<Option.Option<Awaited<ReturnType<StorageManager[K]>>>> =>\n  Effect.suspend(() =>\n    Option.match(\n      Option.filter(storage(), (s) => typeof s[method] === 'function'),\n      {\n        onNone: () => Effect.succeed(Option.none()),\n        onSome: (s) =>\n          Effect.tryPromise(\n            () =>\n              s[method]() as Promise<Awaited<ReturnType<StorageManager[K]>>>,\n          ).pipe(Effect.map(Option.some), Effect.orElseSucceed(Option.none)),\n      },\n    ),\n  );\n\n/** Persistent storage and usage. Every member is none where the Storage API is missing. */\nexport class StoragePersistence extends Context.Service<\n  StoragePersistence,\n  {\n    readonly persisted: Effect.Effect<Option.Option<boolean>>;\n    readonly persist: Effect.Effect<Option.Option<boolean>>;\n    readonly estimate: Effect.Effect<\n      Option.Option<{ readonly usage: number; readonly quota: number }>\n    >;\n  }\n>()('@kestack/web-platform/pwa/StoragePersistence') {\n  static readonly layer: Layer.Layer<StoragePersistence> = Layer.succeed(this, {\n    persisted: call('persisted'),\n    persist: call('persist'),\n    estimate: call('estimate').pipe(\n      Effect.map(\n        Option.map((estimate) => ({\n          usage: estimate.usage ?? 0,\n          quota: estimate.quota ?? 0,\n        })),\n      ),\n    ),\n  });\n}\n\nconst useStorageService = lazyService(\n  StoragePersistence,\n  StoragePersistence.layer,\n);\n\nconst runOr = <A>(effect: Effect.Effect<A> | undefined, fallback: A) =>\n  effect === undefined ? Promise.resolve(fallback) : Effect.runPromise(effect);\n\n/** `null` while unknown or where the Storage API is missing. */\nexport const useStoragePersistence = (): {\n  readonly persisted: boolean | null;\n  readonly persist: () => Promise<boolean | null>;\n  readonly estimate: () => Promise<{\n    readonly usage: number;\n    readonly quota: number;\n  } | null>;\n} => {\n  const service = useStorageService();\n  const [persisted, setPersisted] = useState<boolean | null>(null);\n\n  useEffect(() => {\n    if (service === undefined) return;\n    let mounted = true;\n    void Effect.runPromise(service.persisted).then(\n      (value) => mounted && setPersisted(Option.getOrNull(value)),\n    );\n    return () => {\n      mounted = false;\n    };\n  }, [service]);\n\n  return useMemo(\n    () => ({\n      persisted,\n      persist: async () => {\n        const value = Option.getOrNull(\n          await runOr(service?.persist, Option.none()),\n        );\n        setPersisted(value);\n        return value;\n      },\n      estimate: async () =>\n        Option.getOrNull(await runOr(service?.estimate, Option.none())),\n    }),\n    [persisted, service],\n  );\n};\n"],"mappings":";;;;;;;AAOA,MAAM,gBACJ,OAAO,cAAc,eAAe,UAAU,YAAY,KAAA,IACtD,OAAO,KAAK,UAAU,OAAO,IAC7B,OAAO,KAAK;AAElB,MAAM,QACJ,WAEA,OAAO,cACL,OAAO,MACL,OAAO,OAAO,QAAQ,IAAI,MAAM,OAAO,EAAE,YAAY,UAAU,GAC/D;CACE,cAAc,OAAO,QAAQ,OAAO,KAAK,CAAC;CAC1C,SAAS,MACP,OAAO,iBAEH,EAAE,OAAO,CAAC,CACd,CAAC,CAAC,KAAK,OAAO,IAAI,OAAO,IAAI,GAAG,OAAO,cAAc,OAAO,IAAI,CAAC;AACrE,CACF,CACF;;AAGF,IAAa,qBAAb,cAAwC,QAAQ,QAS9C,CAAC,CAAC,8CAA8C,CAAC,CAAC;CAClD,OAAgB,QAAyC,MAAM,QAAQ,MAAM;EAC3E,WAAW,KAAK,WAAW;EAC3B,SAAS,KAAK,SAAS;EACvB,UAAU,KAAK,UAAU,CAAC,CAAC,KACzB,OAAO,IACL,OAAO,KAAK,cAAc;GACxB,OAAO,SAAS,SAAS;GACzB,OAAO,SAAS,SAAS;EAC3B,EAAE,CACJ,CACF;CACF,CAAC;AACH;AAEA,MAAM,oBAAoB,YACxB,oBACA,mBAAmB,KACrB;AAEA,MAAM,SAAY,QAAsC,aACtD,WAAW,KAAA,IAAY,QAAQ,QAAQ,QAAQ,IAAI,OAAO,WAAW,MAAM;;AAG7E,MAAa,8BAOR;CACH,MAAM,UAAU,kBAAkB;CAClC,MAAM,CAAC,WAAW,gBAAgB,SAAyB,IAAI;CAE/D,gBAAgB;EACd,IAAI,YAAY,KAAA,GAAW;EAC3B,IAAI,UAAU;EACd,OAAY,WAAW,QAAQ,SAAS,CAAC,CAAC,MACvC,UAAU,WAAW,aAAa,OAAO,UAAU,KAAK,CAAC,CAC5D;EACA,aAAa;GACX,UAAU;EACZ;CACF,GAAG,CAAC,OAAO,CAAC;CAEZ,OAAO,eACE;EACL;EACA,SAAS,YAAY;GACnB,MAAM,QAAQ,OAAO,UACnB,MAAM,MAAM,SAAS,SAAS,OAAO,KAAK,CAAC,CAC7C;GACA,aAAa,KAAK;GAClB,OAAO;EACT;EACA,UAAU,YACR,OAAO,UAAU,MAAM,MAAM,SAAS,UAAU,OAAO,KAAK,CAAC,CAAC;CAClE,IACA,CAAC,WAAW,OAAO,CACrB;AACF"}

package/dist/pwa/index.d.ts

@@ -0,0 +1,8 @@
+import { PwaVersion } from "./react/head.js";
+import { PwaProvider, clearRuntimeCache, pwaHead, usePwa } from "./react/react.js";
+import { UpdatePrompt } from "./react/update-prompt.js";
+import "./react/index.js";
+import { pwaRoot } from "./root/root.js";
+import "./root/index.js";
+import { splashHead, splashScreens } from "./splash/splash.js";
+export { PwaProvider, type PwaVersion, UpdatePrompt, clearRuntimeCache, pwaHead, pwaRoot, splashHead, splashScreens, usePwa };

package/dist/pwa/index.js

@@ -0,0 +1,5 @@
+import { PwaProvider, clearRuntimeCache, pwaHead, usePwa } from "./react/react.js";
+import { UpdatePrompt } from "./react/update-prompt.js";
+import { splashHead, splashScreens } from "./splash/splash.js";
+import { pwaRoot } from "./root/root.js";
+export { PwaProvider, UpdatePrompt, clearRuntimeCache, pwaHead, pwaRoot, splashHead, splashScreens, usePwa };

package/dist/pwa/react/head.d.ts

@@ -0,0 +1,33 @@
+import { ClientBuildInfo } from "../shared/config/config.js";
+import "../shared/config/index.js";
+//#region src/pwa/react/head.d.ts
+export interface HeadTags {
+  readonly meta: Array<{
+    readonly name: string;
+    readonly content: string;
+  }>;
+  readonly links: Array<{
+    readonly rel: string;
+    readonly href: string;
+    readonly sizes?: string;
+  }>;
+}
+/**
+ * The build this page came from. `builtAt` is an ISO 8601 string, so the
+ * server and the browser render the same text; format it after mount.
+ * Each field is `null` when the build has none (`buildId` while the PWA is off).
+ */
+export interface PwaVersion {
+  readonly buildId: string | null;
+  readonly builtAt: string | null;
+  readonly commit: string | null;
+}
+/**
+ * The server knows the build from the virtual module; the client build does
+ * not, so in the browser it reads the tags the server rendered. The page
+ * then reports the build that rendered it, even while a newer one waits.
+ */
+export declare const pageVersion: (info: ClientBuildInfo) => PwaVersion;
+export declare const headTags: (info: ClientBuildInfo, version: PwaVersion) => HeadTags;
+//#endregion
+//# sourceMappingURL=head.d.ts.map

package/dist/pwa/react/head.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.d.ts","names":[],"sources":["../../../src/pwa/react/head.ts"],"mappings":";;;iBAOiB;WACN,MAAM;aAAiB;aAAuB;;WAC9C,OAAO;aACL;aACA;aACA;;;;;;;;iBASI;WACN;WACA;WACA;;;;;;;qBAYE,cAAW,MAAU,oBAAkB;qBAYvC,WAAQ,MACb,iBAAe,SACZ,eACR"}

package/dist/pwa/react/head.js

@@ -0,0 +1,43 @@
+import { BUILD_ID_META_NAME, BUILT_AT_META_NAME, COMMIT_META_NAME } from "../shared/build/build.js";
+//#region src/pwa/react/head.ts
+const metaContent = (name) => document.querySelector(`meta[name="${name}"]`)?.getAttribute("content") ?? null;
+/**
+* The server knows the build from the virtual module; the client build does
+* not, so in the browser it reads the tags the server rendered. The page
+* then reports the build that rendered it, even while a newer one waits.
+*/
+const pageVersion = (info) => typeof document === "undefined" ? {
+	buildId: info.buildId,
+	builtAt: info.builtAt,
+	commit: info.commit
+} : {
+	buildId: metaContent(BUILD_ID_META_NAME),
+	builtAt: metaContent(BUILT_AT_META_NAME),
+	commit: metaContent(COMMIT_META_NAME)
+};
+const metaOf = (name, content) => content === null ? [] : [{
+	name,
+	content
+}];
+const headTags = (info, version) => ({
+	meta: [
+		{
+			name: "mobile-web-app-capable",
+			content: "yes"
+		},
+		...metaOf(BUILD_ID_META_NAME, version.buildId),
+		...metaOf(BUILT_AT_META_NAME, version.builtAt),
+		...metaOf(COMMIT_META_NAME, version.commit)
+	],
+	links: [...info.manifestUrl === null ? [] : [{
+		rel: "manifest",
+		href: info.manifestUrl
+	}], ...info.appleTouchIconUrl === null ? [] : [{
+		rel: "apple-touch-icon",
+		href: info.appleTouchIconUrl
+	}]]
+});
+//#endregion
+export { headTags, pageVersion };
+
+//# sourceMappingURL=head.js.map

package/dist/pwa/react/head.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.js","names":[],"sources":["../../../src/pwa/react/head.ts"],"sourcesContent":["import {\n  BUILD_ID_META_NAME,\n  BUILT_AT_META_NAME,\n  COMMIT_META_NAME,\n} from '../shared/build/index.js';\nimport type { ClientBuildInfo } from '../shared/config/index.js';\n\nexport interface HeadTags {\n  readonly meta: Array<{ readonly name: string; readonly content: string }>;\n  readonly links: Array<{\n    readonly rel: string;\n    readonly href: string;\n    readonly sizes?: string;\n  }>;\n}\n\n/**\n * The build this page came from. `builtAt` is an ISO 8601 string, so the\n * server and the browser render the same text; format it after mount.\n * Each field is `null` when the build has none (`buildId` while the PWA is off).\n */\nexport interface PwaVersion {\n  readonly buildId: string | null;\n  readonly builtAt: string | null;\n  readonly commit: string | null;\n}\n\nconst metaContent = (name: string): string | null =>\n  document.querySelector(`meta[name=\"${name}\"]`)?.getAttribute('content') ??\n  null;\n\n/**\n * The server knows the build from the virtual module; the client build does\n * not, so in the browser it reads the tags the server rendered. The page\n * then reports the build that rendered it, even while a newer one waits.\n */\nexport const pageVersion = (info: ClientBuildInfo): PwaVersion =>\n  typeof document === 'undefined'\n    ? { buildId: info.buildId, builtAt: info.builtAt, commit: info.commit }\n    : {\n        buildId: metaContent(BUILD_ID_META_NAME),\n        builtAt: metaContent(BUILT_AT_META_NAME),\n        commit: metaContent(COMMIT_META_NAME),\n      };\n\nconst metaOf = (name: string, content: string | null) =>\n  content === null ? [] : [{ name, content }];\n\nexport const headTags = (\n  info: ClientBuildInfo,\n  version: PwaVersion,\n): HeadTags => ({\n  // No `apple-mobile-web-app-capable`: it puts iOS home-screen apps in the\n  // legacy mode, where the status bar ignores an in-place theme switch.\n  meta: [\n    { name: 'mobile-web-app-capable', content: 'yes' },\n    ...metaOf(BUILD_ID_META_NAME, version.buildId),\n    ...metaOf(BUILT_AT_META_NAME, version.builtAt),\n    ...metaOf(COMMIT_META_NAME, version.commit),\n  ],\n  links: [\n    ...(info.manifestUrl === null\n      ? []\n      : [{ rel: 'manifest', href: info.manifestUrl }]),\n    ...(info.appleTouchIconUrl === null\n      ? []\n      : [{ rel: 'apple-touch-icon', href: info.appleTouchIconUrl }]),\n  ],\n});\n"],"mappings":";;AA2BA,MAAM,eAAe,SACnB,SAAS,cAAc,cAAc,KAAK,GAAG,CAAC,EAAE,aAAa,SAAS,KACtE;;;;;;AAOF,MAAa,eAAe,SAC1B,OAAO,aAAa,cAChB;CAAE,SAAS,KAAK;CAAS,SAAS,KAAK;CAAS,QAAQ,KAAK;AAAO,IACpE;CACE,SAAS,YAAY,kBAAkB;CACvC,SAAS,YAAY,kBAAkB;CACvC,QAAQ,YAAY,gBAAgB;AACtC;AAEN,MAAM,UAAU,MAAc,YAC5B,YAAY,OAAO,CAAC,IAAI,CAAC;CAAE;CAAM;AAAQ,CAAC;AAE5C,MAAa,YACX,MACA,aACc;CAGd,MAAM;EACJ;GAAE,MAAM;GAA0B,SAAS;EAAM;EACjD,GAAG,OAAO,oBAAoB,QAAQ,OAAO;EAC7C,GAAG,OAAO,oBAAoB,QAAQ,OAAO;EAC7C,GAAG,OAAO,kBAAkB,QAAQ,MAAM;CAC5C;CACA,OAAO,CACL,GAAI,KAAK,gBAAgB,OACrB,CAAC,IACD,CAAC;EAAE,KAAK;EAAY,MAAM,KAAK;CAAY,CAAC,GAChD,GAAI,KAAK,sBAAsB,OAC3B,CAAC,IACD,CAAC;EAAE,KAAK;EAAoB,MAAM,KAAK;CAAkB,CAAC,CAChE;AACF"}

package/dist/pwa/react/index.d.ts

@@ -0,0 +1,4 @@
+import { PwaVersion } from "./head.js";
+import { PwaProvider, clearRuntimeCache, pwaHead, usePwa } from "./react.js";
+import { UpdatePrompt } from "./update-prompt.js";
+export { PwaProvider, type PwaVersion, UpdatePrompt, clearRuntimeCache, pwaHead, usePwa };

package/dist/pwa/react/index.js

@@ -0,0 +1,3 @@
+import { PwaProvider, clearRuntimeCache, pwaHead, usePwa } from "./react.js";
+import { UpdatePrompt } from "./update-prompt.js";
+export { PwaProvider, UpdatePrompt, clearRuntimeCache, pwaHead, usePwa };

package/dist/pwa/react/react.d.ts

@@ -0,0 +1,33 @@
+import { PwaStatus } from "../client/status/status.js";
+import "../client/index.js";
+import { HeadTags, PwaVersion } from "./head.js";
+import { ReactNode } from "react";
+//#region src/pwa/react/react.d.ts
+/**
+ * Registers the service worker after mount (never during SSR) and gives
+ * `usePwa` its status. Render it once, in the root route.
+ */
+export declare const PwaProvider: (props: {
+  readonly children?: ReactNode;
+}) => ReactNode;
+/**
+ * The PWA's status with `checkForUpdate` and `applyUpdate`, and the
+ * `version` this page runs. `status` is `Unsupported` during SSR and until
+ * `PwaProvider` has started; `version` is known from the first render.
+ */
+export declare const usePwa: () => {
+  readonly status: PwaStatus;
+  readonly version: PwaVersion;
+  readonly checkForUpdate: () => Promise<void>;
+  readonly applyUpdate: () => Promise<void>;
+};
+/** Deletes every Runtime Cache. Works outside `PwaProvider` (e.g. in sign-out). */
+export declare const clearRuntimeCache: () => Promise<void>;
+/**
+ * Head tags for the root route: manifest link, Apple icon, and the meta
+ * tags for the Build ID (read by Worker RPC), build time and commit.
+ * Hydration-safe: in the browser they come from the tags the server rendered.
+ */
+export declare const pwaHead: () => HeadTags;
+//#endregion
+//# sourceMappingURL=react.d.ts.map

package/dist/pwa/react/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","names":[],"sources":["../../../src/pwa/react/react.tsx"],"mappings":";;;;;;;;;qBAkCa,cAAW;WACb,WAAW;MAClB;;;;;;qBA4BS;WACF,QAAQ;WACR,SAAS;WACT,sBAAsB;WACtB,mBAAmB;;;qBAqBjB,yBAAwB;;;;;;qBAQxB,eAAc"}

package/dist/pwa/react/react.js

@@ -0,0 +1,67 @@
+import { useSubscriptionRef } from "../browser/subscription-ref.js";
+import { PwaStatus } from "../client/status/status.js";
+import { Pwa, clearRuntimeCache as clearRuntimeCache$1 } from "../client/client.js";
+import { headTags, pageVersion } from "./head.js";
+import { createContext, useContext, useEffect, useMemo, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as ManagedRuntime from "effect/ManagedRuntime";
+import info from "virtual:pwa-toolkit/client";
+//#region src/pwa/react/react.tsx
+/** `null` outside `PwaProvider`, during SSR, and until the service is built. */
+const PwaContext = createContext(null);
+const UNSUPPORTED = PwaStatus.Unsupported();
+/**
+* Registers the service worker after mount (never during SSR) and gives
+* `usePwa` its status. Render it once, in the root route.
+*/
+const PwaProvider = (props) => {
+	const [pwa, setPwa] = useState(null);
+	useEffect(() => {
+		const runtime = ManagedRuntime.make(Pwa.layer(info));
+		let mounted = true;
+		runtime.context().then((context) => mounted && setPwa(Context.get(context, Pwa)), (error) => console.error("pwa-toolkit: client failed to start", error));
+		return () => {
+			mounted = false;
+			setPwa(null);
+			runtime.dispose();
+		};
+	}, []);
+	return /* @__PURE__ */ jsx(PwaContext.Provider, {
+		value: pwa,
+		children: props.children
+	});
+};
+/**
+* The PWA's status with `checkForUpdate` and `applyUpdate`, and the
+* `version` this page runs. `status` is `Unsupported` during SSR and until
+* `PwaProvider` has started; `version` is known from the first render.
+*/
+const usePwa = () => {
+	const pwa = useContext(PwaContext);
+	const status = useSubscriptionRef(pwa?.status, UNSUPPORTED);
+	const version = useMemo(() => pageVersion(info), []);
+	return useMemo(() => ({
+		status,
+		version,
+		checkForUpdate: () => pwa === null ? Promise.resolve() : Effect.runPromise(pwa.checkForUpdate),
+		applyUpdate: () => pwa === null ? Promise.resolve() : Effect.runPromise(pwa.applyUpdate)
+	}), [
+		status,
+		version,
+		pwa
+	]);
+};
+/** Deletes every Runtime Cache. Works outside `PwaProvider` (e.g. in sign-out). */
+const clearRuntimeCache = () => Effect.runPromise(clearRuntimeCache$1);
+/**
+* Head tags for the root route: manifest link, Apple icon, and the meta
+* tags for the Build ID (read by Worker RPC), build time and commit.
+* Hydration-safe: in the browser they come from the tags the server rendered.
+*/
+const pwaHead = () => headTags(info, pageVersion(info));
+//#endregion
+export { PwaProvider, clearRuntimeCache, pwaHead, usePwa };
+
+//# sourceMappingURL=react.js.map

package/dist/pwa/react/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","names":["clearRuntimeCacheEffect"],"sources":["../../../src/pwa/react/react.tsx"],"sourcesContent":["import * as Context from 'effect/Context';\nimport * as Effect from 'effect/Effect';\nimport * as ManagedRuntime from 'effect/ManagedRuntime';\nimport {\n  createContext,\n  type ReactNode,\n  useContext,\n  useEffect,\n  useMemo,\n  useState,\n} from 'react';\nimport info from 'virtual:pwa-toolkit/client';\nimport { useSubscriptionRef } from '../browser/subscription-ref.js';\nimport {\n  clearRuntimeCache as clearRuntimeCacheEffect,\n  Pwa,\n  PwaStatus,\n} from '../client/index.js';\nimport {\n  type HeadTags,\n  headTags,\n  pageVersion,\n  type PwaVersion,\n} from './head.js';\n\n/** `null` outside `PwaProvider`, during SSR, and until the service is built. */\nconst PwaContext = createContext<Pwa['Service'] | null>(null);\n\nconst UNSUPPORTED = PwaStatus.Unsupported();\n\n/**\n * Registers the service worker after mount (never during SSR) and gives\n * `usePwa` its status. Render it once, in the root route.\n */\nexport const PwaProvider = (props: {\n  readonly children?: ReactNode;\n}): ReactNode => {\n  const [pwa, setPwa] = useState<Pwa['Service'] | null>(null);\n\n  useEffect(() => {\n    const runtime = ManagedRuntime.make(Pwa.layer(info));\n    let mounted = true;\n    runtime.context().then(\n      (context) => mounted && setPwa(Context.get(context, Pwa)),\n      (error: unknown) =>\n        console.error('pwa-toolkit: client failed to start', error),\n    );\n    return () => {\n      mounted = false;\n      setPwa(null);\n      void runtime.dispose();\n    };\n  }, []);\n\n  return (\n    <PwaContext.Provider value={pwa}>{props.children}</PwaContext.Provider>\n  );\n};\n\n/**\n * The PWA's status with `checkForUpdate` and `applyUpdate`, and the\n * `version` this page runs. `status` is `Unsupported` during SSR and until\n * `PwaProvider` has started; `version` is known from the first render.\n */\nexport const usePwa = (): {\n  readonly status: PwaStatus;\n  readonly version: PwaVersion;\n  readonly checkForUpdate: () => Promise<void>;\n  readonly applyUpdate: () => Promise<void>;\n} => {\n  const pwa = useContext(PwaContext);\n  const status = useSubscriptionRef(pwa?.status, UNSUPPORTED);\n  const version = useMemo(() => pageVersion(info), []);\n  return useMemo(\n    () => ({\n      status,\n      version,\n      checkForUpdate: () =>\n        pwa === null\n          ? Promise.resolve()\n          : Effect.runPromise(pwa.checkForUpdate),\n      applyUpdate: () =>\n        pwa === null ? Promise.resolve() : Effect.runPromise(pwa.applyUpdate),\n    }),\n    [status, version, pwa],\n  );\n};\n\n/** Deletes every Runtime Cache. Works outside `PwaProvider` (e.g. in sign-out). */\nexport const clearRuntimeCache = (): Promise<void> =>\n  Effect.runPromise(clearRuntimeCacheEffect);\n\n/**\n * Head tags for the root route: manifest link, Apple icon, and the meta\n * tags for the Build ID (read by Worker RPC), build time and commit.\n * Hydration-safe: in the browser they come from the tags the server rendered.\n */\nexport const pwaHead = (): HeadTags => headTags(info, pageVersion(info));\n"],"mappings":";;;;;;;;;;;;AA0BA,MAAM,aAAa,cAAqC,IAAI;AAE5D,MAAM,cAAc,UAAU,YAAY;;;;;AAM1C,MAAa,eAAe,UAEX;CACf,MAAM,CAAC,KAAK,UAAU,SAAgC,IAAI;CAE1D,gBAAgB;EACd,MAAM,UAAU,eAAe,KAAK,IAAI,MAAM,IAAI,CAAC;EACnD,IAAI,UAAU;EACd,QAAQ,QAAQ,CAAC,CAAC,MACf,YAAY,WAAW,OAAO,QAAQ,IAAI,SAAS,GAAG,CAAC,IACvD,UACC,QAAQ,MAAM,uCAAuC,KAAK,CAC9D;EACA,aAAa;GACX,UAAU;GACV,OAAO,IAAI;GACX,QAAa,QAAQ;EACvB;CACF,GAAG,CAAC,CAAC;CAEL,OACE,oBAAC,WAAW,UAAZ;EAAqB,OAAO;EAAM,UAAA,MAAM;CAA8B,CAAA;AAE1E;;;;;;AAOA,MAAa,eAKR;CACH,MAAM,MAAM,WAAW,UAAU;CACjC,MAAM,SAAS,mBAAmB,KAAK,QAAQ,WAAW;CAC1D,MAAM,UAAU,cAAc,YAAY,IAAI,GAAG,CAAC,CAAC;CACnD,OAAO,eACE;EACL;EACA;EACA,sBACE,QAAQ,OACJ,QAAQ,QAAQ,IAChB,OAAO,WAAW,IAAI,cAAc;EAC1C,mBACE,QAAQ,OAAO,QAAQ,QAAQ,IAAI,OAAO,WAAW,IAAI,WAAW;CACxE,IACA;EAAC;EAAQ;EAAS;CAAG,CACvB;AACF;;AAGA,MAAa,0BACX,OAAO,WAAWA,mBAAuB;;;;;;AAO3C,MAAa,gBAA0B,SAAS,MAAM,YAAY,IAAI,CAAC"}

package/dist/pwa/react/update-prompt.d.ts

@@ -0,0 +1,12 @@
+import { ReactNode } from "react";
+//#region src/pwa/react/update-prompt.d.ts
+/**
+ * Persistent toast while an update is ready; accepting applies it.
+ * Renders its own toast viewport, so it does not need the app's `Toaster`.
+ */
+export declare const UpdatePrompt: (props: {
+  readonly message?: string;
+  readonly acceptLabel?: string;
+}) => ReactNode;
+//#endregion
+//# sourceMappingURL=update-prompt.d.ts.map

package/dist/pwa/react/update-prompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-prompt.d.ts","names":[],"sources":["../../../src/pwa/react/update-prompt.tsx"],"mappings":";;;;;;qBASa,eAAY;WACd;WACA;MACP"}

package/dist/pwa/react/update-prompt.js

@@ -0,0 +1,23 @@
+import { usePwa } from "./react.js";
+import { Toaster, createToastManager } from "../../components/ui/toast.js";
+import { useUpdateToast } from "./update-toast.js";
+import { useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/pwa/react/update-prompt.tsx
+/**
+* Persistent toast while an update is ready; accepting applies it.
+* Renders its own toast viewport, so it does not need the app's `Toaster`.
+*/
+const UpdatePrompt = (props) => {
+	const { status, applyUpdate } = usePwa();
+	const [manager] = useState(createToastManager);
+	useUpdateToast(manager, status, {
+		message: props.message ?? "A new version is available.",
+		acceptLabel: props.acceptLabel ?? "Reload"
+	}, applyUpdate);
+	return /* @__PURE__ */ jsx(Toaster, { toastManager: manager });
+};
+//#endregion
+export { UpdatePrompt };
+
+//# sourceMappingURL=update-prompt.js.map

package/dist/pwa/react/update-prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-prompt.js","names":[],"sources":["../../../src/pwa/react/update-prompt.tsx"],"sourcesContent":["import { createToastManager, Toaster } from '#components/ui/toast';\nimport { type ReactNode, useState } from 'react';\nimport { usePwa } from './react.js';\nimport { useUpdateToast } from './update-toast.js';\n\n/**\n * Persistent toast while an update is ready; accepting applies it.\n * Renders its own toast viewport, so it does not need the app's `Toaster`.\n */\nexport const UpdatePrompt = (props: {\n  readonly message?: string;\n  readonly acceptLabel?: string;\n}): ReactNode => {\n  const { status, applyUpdate } = usePwa();\n  const [manager] = useState(createToastManager);\n  useUpdateToast(\n    manager,\n    status,\n    {\n      message: props.message ?? 'A new version is available.',\n      acceptLabel: props.acceptLabel ?? 'Reload',\n    },\n    applyUpdate,\n  );\n  return <Toaster toastManager={manager} />;\n};\n"],"mappings":";;;;;;;;;;AASA,MAAa,gBAAgB,UAGZ;CACf,MAAM,EAAE,QAAQ,gBAAgB,OAAO;CACvC,MAAM,CAAC,WAAW,SAAS,kBAAkB;CAC7C,eACE,SACA,QACA;EACE,SAAS,MAAM,WAAW;EAC1B,aAAa,MAAM,eAAe;CACpC,GACA,WACF;CACA,OAAO,oBAAC,SAAD,EAAS,cAAc,QAAU,CAAA;AAC1C"}

package/dist/pwa/react/update-toast.d.ts

@@ -0,0 +1,15 @@
+import { createToastManager } from "../../components/ui/toast.js";
+import { PwaStatus } from "../client/status/status.js";
+import "../client/index.js";
+//#region src/pwa/react/update-toast.d.ts
+type ToastManager = ReturnType<typeof createToastManager>;
+/**
+ * Mirrors the status into one persistent toast: shown while UpdateReady,
+ * busy while Updating, gone otherwise. Closing it hides it until the next update.
+ */
+export declare const useUpdateToast: (manager: ToastManager, status: PwaStatus, labels: {
+  readonly message: string;
+  readonly acceptLabel: string;
+}, apply: () => Promise<void>) => void;
+//#endregion
+//# sourceMappingURL=update-toast.d.ts.map

package/dist/pwa/react/update-toast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-toast.d.ts","names":[],"sources":["../../../src/pwa/react/update-toast.ts"],"mappings":";;;;KAIK,eAAe,kBAAkB;;;;;qBAMzB,iBAAc,SAChB,cAAY,QACb,WAAS;WACE;WAA0B;GAAqB,aACrD"}

package/dist/pwa/react/update-toast.js

@@ -0,0 +1,52 @@
+import { useEffect, useRef } from "react";
+//#region src/pwa/react/update-toast.ts
+/**
+* Mirrors the status into one persistent toast: shown while UpdateReady,
+* busy while Updating, gone otherwise. Closing it hides it until the next update.
+*/
+const useUpdateToast = (manager, status, labels, apply) => {
+	const id = useRef(null);
+	const closed = useRef(false);
+	const latestApply = useRef(apply);
+	latestApply.current = apply;
+	useEffect(() => {
+		const tag = status._tag;
+		if (tag !== "UpdateReady" && tag !== "Updating") {
+			const open = id.current;
+			id.current = null;
+			closed.current = false;
+			if (open !== null) manager.close(open);
+			return;
+		}
+		if (closed.current) return;
+		const applying = tag === "Updating";
+		const options = {
+			title: labels.message,
+			type: applying ? "loading" : void 0,
+			timeout: 0,
+			actionProps: {
+				children: labels.acceptLabel,
+				disabled: applying,
+				onClick: () => void latestApply.current()
+			}
+		};
+		if (id.current === null) id.current = manager.add({
+			...options,
+			onClose: () => {
+				if (id.current === null) return;
+				id.current = null;
+				closed.current = true;
+			}
+		});
+		else manager.update(id.current, options);
+	}, [
+		manager,
+		status._tag,
+		labels.message,
+		labels.acceptLabel
+	]);
+};
+//#endregion
+export { useUpdateToast };
+
+//# sourceMappingURL=update-toast.js.map

package/dist/pwa/react/update-toast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"update-toast.js","names":[],"sources":["../../../src/pwa/react/update-toast.ts"],"sourcesContent":["import type { createToastManager } from '#components/ui/toast';\nimport { useEffect, useRef } from 'react';\nimport type { PwaStatus } from '../client/index.js';\n\ntype ToastManager = ReturnType<typeof createToastManager>;\n\n/**\n * Mirrors the status into one persistent toast: shown while UpdateReady,\n * busy while Updating, gone otherwise. Closing it hides it until the next update.\n */\nexport const useUpdateToast = (\n  manager: ToastManager,\n  status: PwaStatus,\n  labels: { readonly message: string; readonly acceptLabel: string },\n  apply: () => Promise<void>,\n): void => {\n  const id = useRef<string | null>(null);\n  const closed = useRef(false);\n  const latestApply = useRef(apply);\n  latestApply.current = apply;\n\n  useEffect(() => {\n    const tag = status._tag;\n    if (tag !== 'UpdateReady' && tag !== 'Updating') {\n      const open = id.current;\n      id.current = null;\n      closed.current = false;\n      if (open !== null) manager.close(open);\n      return;\n    }\n    if (closed.current) return;\n    const applying = tag === 'Updating';\n    const options = {\n      title: labels.message,\n      type: applying ? 'loading' : undefined,\n      timeout: 0,\n      actionProps: {\n        children: labels.acceptLabel,\n        disabled: applying,\n        onClick: () => void latestApply.current(),\n      },\n    };\n    if (id.current === null) {\n      id.current = manager.add({\n        ...options,\n        // Also fires for our own `close` above, after `id` is already cleared.\n        onClose: () => {\n          if (id.current === null) return;\n          id.current = null;\n          closed.current = true;\n        },\n      });\n    } else {\n      manager.update(id.current, options);\n    }\n  }, [manager, status._tag, labels.message, labels.acceptLabel]);\n};\n"],"mappings":";;;;;;AAUA,MAAa,kBACX,SACA,QACA,QACA,UACS;CACT,MAAM,KAAK,OAAsB,IAAI;CACrC,MAAM,SAAS,OAAO,KAAK;CAC3B,MAAM,cAAc,OAAO,KAAK;CAChC,YAAY,UAAU;CAEtB,gBAAgB;EACd,MAAM,MAAM,OAAO;EACnB,IAAI,QAAQ,iBAAiB,QAAQ,YAAY;GAC/C,MAAM,OAAO,GAAG;GAChB,GAAG,UAAU;GACb,OAAO,UAAU;GACjB,IAAI,SAAS,MAAM,QAAQ,MAAM,IAAI;GACrC;EACF;EACA,IAAI,OAAO,SAAS;EACpB,MAAM,WAAW,QAAQ;EACzB,MAAM,UAAU;GACd,OAAO,OAAO;GACd,MAAM,WAAW,YAAY,KAAA;GAC7B,SAAS;GACT,aAAa;IACX,UAAU,OAAO;IACjB,UAAU;IACV,eAAe,KAAK,YAAY,QAAQ;GAC1C;EACF;EACA,IAAI,GAAG,YAAY,MACjB,GAAG,UAAU,QAAQ,IAAI;GACvB,GAAG;GAEH,eAAe;IACb,IAAI,GAAG,YAAY,MAAM;IACzB,GAAG,UAAU;IACb,OAAO,UAAU;GACnB;EACF,CAAC;OAED,QAAQ,OAAO,GAAG,SAAS,OAAO;CAEtC,GAAG;EAAC;EAAS,OAAO;EAAM,OAAO;EAAS,OAAO;CAAW,CAAC;AAC/D"}

package/dist/pwa/root/index.d.ts

@@ -0,0 +1,2 @@
+import { pwaRoot } from "./root.js";
+export { pwaRoot };

package/dist/pwa/root/index.js

@@ -0,0 +1,2 @@
+import { pwaRoot } from "./root.js";
+export { pwaRoot };

package/dist/pwa/root/root.d.ts

@@ -0,0 +1,14 @@
+import { RootPlugin } from "../../client/root/root.js";
+import "../../client/index.js";
+//#region src/pwa/root/root.d.ts
+/**
+ * The PWA, plugged into the root document: the manifest, icons, Build ID
+ * and iOS splash tags in every page's head; the service worker registered
+ * after mount; the Update Prompt when a new version waits; and the Install
+ * Prompt, offered once. Leave it out and the app is no PWA.
+ */
+export declare const pwaRoot: (options?: {
+  readonly installTitle?: string;
+}) => RootPlugin;
+//#endregion
+//# sourceMappingURL=root.d.ts.map

package/dist/pwa/root/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","names":[],"sources":["../../../src/pwa/root/root.tsx"],"mappings":";;;;;;;;;qBAYa,UAAO;WACE;MACnB"}

package/dist/pwa/root/root.js

@@ -0,0 +1,35 @@
+import { PwaProvider, pwaHead } from "../react/react.js";
+import { UpdatePrompt } from "../react/update-prompt.js";
+import { useInstall } from "../extras/install/install.js";
+import { InstallPrompt } from "../extras/install/install-prompt.js";
+import { splashHead } from "../splash/splash.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+//#region src/pwa/root/root.tsx
+/**
+* The PWA, plugged into the root document: the manifest, icons, Build ID
+* and iOS splash tags in every page's head; the service worker registered
+* after mount; the Update Prompt when a new version waits; and the Install
+* Prompt, offered once. Leave it out and the app is no PWA.
+*/
+const pwaRoot = (options = {}) => ({
+	head: () => {
+		const pwa = pwaHead();
+		const splash = splashHead();
+		return {
+			meta: [...pwa.meta, ...splash.meta],
+			links: [...pwa.links, ...splash.links]
+		};
+	},
+	Provider: (props) => {
+		useInstall();
+		return /* @__PURE__ */ jsxs(PwaProvider, { children: [
+			props.children,
+			/* @__PURE__ */ jsx(UpdatePrompt, {}),
+			/* @__PURE__ */ jsx(InstallPrompt, { ...options.installTitle === void 0 ? {} : { title: options.installTitle } })
+		] });
+	}
+});
+//#endregion
+export { pwaRoot };
+
+//# sourceMappingURL=root.js.map

package/dist/pwa/root/root.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.js","names":[],"sources":["../../../src/pwa/root/root.tsx"],"sourcesContent":["import type { ReactNode } from 'react';\nimport type { RootPlugin } from '../../client/index.ts';\nimport { InstallPrompt, useInstall } from '../extras/index.js';\nimport { PwaProvider, pwaHead, UpdatePrompt } from '../react/index.js';\nimport { splashHead } from '../splash/index.ts';\n\n/**\n * The PWA, plugged into the root document: the manifest, icons, Build ID\n * and iOS splash tags in every page's head; the service worker registered\n * after mount; the Update Prompt when a new version waits; and the Install\n * Prompt, offered once. Leave it out and the app is no PWA.\n */\nexport const pwaRoot = (\n  options: { readonly installTitle?: string } = {},\n): RootPlugin => ({\n  head: () => {\n    const pwa = pwaHead();\n    const splash = splashHead();\n    return {\n      meta: [...pwa.meta, ...splash.meta],\n      links: [...pwa.links, ...splash.links],\n    };\n  },\n  Provider: (props: { readonly children: ReactNode }) => {\n    // The browser offers install once, early, so it is caught at the root.\n    useInstall();\n    return (\n      <PwaProvider>\n        {props.children}\n        <UpdatePrompt />\n        <InstallPrompt\n          {...(options.installTitle === undefined\n            ? {}\n            : { title: options.installTitle })}\n        />\n      </PwaProvider>\n    );\n  },\n});\n"],"mappings":";;;;;;;;;;;;;AAYA,MAAa,WACX,UAA8C,CAAC,OAC/B;CAChB,YAAY;EACV,MAAM,MAAM,QAAQ;EACpB,MAAM,SAAS,WAAW;EAC1B,OAAO;GACL,MAAM,CAAC,GAAG,IAAI,MAAM,GAAG,OAAO,IAAI;GAClC,OAAO,CAAC,GAAG,IAAI,OAAO,GAAG,OAAO,KAAK;EACvC;CACF;CACA,WAAW,UAA4C;EAErD,WAAW;EACX,OACE,qBAAC,aAAD,EAAA,UAAA;GACG,MAAM;GACP,oBAAC,cAAD,CAAe,CAAA;GACf,oBAAC,eAAD,EACE,GAAK,QAAQ,iBAAiB,KAAA,IAC1B,CAAC,IACD,EAAE,OAAO,QAAQ,aAAa,EACnC,CAAA;EACU,EAAA,CAAA;CAEjB;AACF"}

package/dist/pwa/rpc/client/client.d.ts

@@ -0,0 +1,49 @@
+import { VersionSkew } from "../handshake/handshake.js";
+import "../handshake/index.js";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Duration from "effect/Duration";
+import * as RpcClient from "effect/rpc/RpcClient";
+import * as Scope from "effect/Scope";
+import { WorkerError } from "effect/workers/WorkerError";
+import * as Rpc from "effect/rpc/Rpc";
+import { RpcClientError } from "effect/rpc/RpcClientError";
+import * as RpcGroup from "effect/rpc/RpcGroup";
+//#region src/pwa/rpc/client/client.d.ts
+type Client<Rpcs extends Rpc.Any> = RpcClient.RpcClient<Rpcs, RpcClientError | VersionSkew>;
+interface Options {
+  /**
+   * While calls are in flight, how often the Worker Client checks that the
+   * Worker Server still knows it; also how long it waits for the handshake.
+   * Default 5 seconds.
+   */
+  readonly livenessInterval?: Duration.Input;
+}
+declare const make: <Rpcs extends Rpc.Any>(group: RpcGroup.RpcGroup<Rpcs>, options?: Options) => Effect.Effect<Client<Rpcs>, WorkerError, Scope.Scope | Rpc.MiddlewareClient<Rpcs>>;
+/**
+ * One page's Worker RPC connection. Every message goes through the current
+ * controller, carrying the page's Build ID (from the meta tag `pwaHead()`
+ * renders). On a first visit, calls wait for the worker to take control.
+ * `make` fails at once when no worker ever will: the PWA is off in this
+ * build, or a hard reload left the page uncontrolled.
+ *
+ * - Version Skew: a worker of another Build ID refuses the connection, and
+ *   calls fail with `VersionSkew` until a new controller takes over. The app
+ *   may answer it with `usePwa().checkForUpdate`.
+ * - Worker restart: the browser may stop the worker at any time. A call made
+ *   while nothing was in flight wakes the new worker and succeeds. Calls in
+ *   flight then fail with `RpcClientError` (found at the next message, or
+ *   within the liveness interval), and the Worker Client connects again on its
+ *   own. A stream is never resumed where it stopped: Subscription Restart
+ *   means subscribing again (e.g. `Stream.retry`), and the handler starts
+ *   over from the current state, so it must emit everything a fresh
+ *   subscriber needs.
+ */
+export declare const WorkerClient: {
+  make: typeof make;
+  layer: <Id, Rpcs extends Rpc.Any>(tag: Context.Key<Id, Client<Rpcs>>, group: RpcGroup.RpcGroup<Rpcs>, options?: Options) => Layer.Layer<Id, WorkerError, Rpc.MiddlewareClient<Rpcs>>;
+};
+//#endregion
+export { VersionSkew };
+//# sourceMappingURL=client.d.ts.map

package/dist/pwa/rpc/client/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","names":[],"sources":["../../../../src/pwa/rpc/client/client.ts"],"mappings":";;;;;;;;;;;;;KAuBK,OAAO,aAAa,IAAI,OAAO,UAAU,UAC5C,MACA,iBAAiB;UAGT;;;;;;WAMC,mBAAmB,SAAS;;cAGjC,OAAQ,aAAa,IAAI,KAAG,OACzB,SAAS,SAAS,OAAK,UACpB,YACT,OAAO,OACR,OAAO,OACP,aACA,MAAM,QAAQ,IAAI,iBAAiB;;;;;;;;;;;;;;;;;;;;qBAqDxB;;EAEH,QAAA,IAAI,aAAa,IAAI,KAAG,KACzB,QAAQ,IAAI,IAAI,OAAO,QAAM,OAC3B,SAAS,SAAS,OAAK,UACpB,YACT,MAAM,MAAM,IAAI,aAAa,IAAI,iBAAiB"}

package/dist/pwa/rpc/client/client.js

@@ -0,0 +1,55 @@
+import { VersionSkew } from "../handshake/handshake.js";
+import { makeClientPlatform } from "./platform.js";
+import { controllerComing, pageBuildId, serviceWorkerContainer } from "./page-environment.js";
+import { makeSkewState, withVersionSkew } from "./version-skew.js";
+import * as Effect from "effect/Effect";
+import info from "virtual:pwa-toolkit/client";
+import * as Layer from "effect/Layer";
+import * as Duration from "effect/Duration";
+import * as RpcClient from "effect/rpc/RpcClient";
+import * as Worker from "effect/workers/Worker";
+//#region src/pwa/rpc/client/client.ts
+const make = (group, options) => Effect.gen(function* () {
+	const buildId = yield* pageBuildId;
+	const container = yield* serviceWorkerContainer;
+	const livenessMs = Duration.toMillis(options?.livenessInterval ?? "5 seconds");
+	yield* controllerComing({
+		enabled: info.enabled,
+		container,
+		graceMs: livenessMs
+	});
+	const skew = makeSkewState();
+	const protocol = yield* RpcClient.makeProtocolWorker({ size: 1 }).pipe(Effect.provideService(Worker.WorkerPlatform, makeClientPlatform({
+		buildId,
+		skew,
+		livenessMs
+	})), Effect.provideService(Worker.Spawner, () => container));
+	return yield* RpcClient.make(group).pipe(Effect.provideService(RpcClient.Protocol, withVersionSkew(protocol, skew)));
+});
+/**
+* One page's Worker RPC connection. Every message goes through the current
+* controller, carrying the page's Build ID (from the meta tag `pwaHead()`
+* renders). On a first visit, calls wait for the worker to take control.
+* `make` fails at once when no worker ever will: the PWA is off in this
+* build, or a hard reload left the page uncontrolled.
+*
+* - Version Skew: a worker of another Build ID refuses the connection, and
+*   calls fail with `VersionSkew` until a new controller takes over. The app
+*   may answer it with `usePwa().checkForUpdate`.
+* - Worker restart: the browser may stop the worker at any time. A call made
+*   while nothing was in flight wakes the new worker and succeeds. Calls in
+*   flight then fail with `RpcClientError` (found at the next message, or
+*   within the liveness interval), and the Worker Client connects again on its
+*   own. A stream is never resumed where it stopped: Subscription Restart
+*   means subscribing again (e.g. `Stream.retry`), and the handler starts
+*   over from the current state, so it must emit everything a fresh
+*   subscriber needs.
+*/
+const WorkerClient = {
+	make,
+	layer: (tag, group, options) => Layer.effect(tag)(make(group, options))
+};
+//#endregion
+export { VersionSkew, WorkerClient };
+
+//# sourceMappingURL=client.js.map

package/dist/pwa/rpc/client/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","names":[],"sources":["../../../../src/pwa/rpc/client/client.ts"],"sourcesContent":["import type * as Context from 'effect/Context';\nimport * as Duration from 'effect/Duration';\nimport * as Effect from 'effect/Effect';\nimport * as Layer from 'effect/Layer';\nimport type * as Scope from 'effect/Scope';\nimport type * as Rpc from 'effect/rpc/Rpc';\nimport * as RpcClient from 'effect/rpc/RpcClient';\nimport type { RpcClientError } from 'effect/rpc/RpcClientError';\nimport type * as RpcGroup from 'effect/rpc/RpcGroup';\nimport * as Worker from 'effect/workers/Worker';\nimport type { WorkerError } from 'effect/workers/WorkerError';\nimport type { VersionSkew } from '../handshake/index.js';\nimport { makeClientPlatform } from './platform.js';\nimport info from 'virtual:pwa-toolkit/client';\nimport {\n  controllerComing,\n  pageBuildId,\n  serviceWorkerContainer,\n} from './page-environment.js';\nimport { makeSkewState, withVersionSkew } from './version-skew.js';\n\nexport { VersionSkew } from '../handshake/index.js';\n\ntype Client<Rpcs extends Rpc.Any> = RpcClient.RpcClient<\n  Rpcs,\n  RpcClientError | VersionSkew\n>;\n\ninterface Options {\n  /**\n   * While calls are in flight, how often the Worker Client checks that the\n   * Worker Server still knows it; also how long it waits for the handshake.\n   * Default 5 seconds.\n   */\n  readonly livenessInterval?: Duration.Input;\n}\n\nconst make = <Rpcs extends Rpc.Any>(\n  group: RpcGroup.RpcGroup<Rpcs>,\n  options?: Options,\n): Effect.Effect<\n  Client<Rpcs>,\n  WorkerError,\n  Scope.Scope | Rpc.MiddlewareClient<Rpcs>\n> =>\n  Effect.gen(function* () {\n    const buildId = yield* pageBuildId;\n    const container = yield* serviceWorkerContainer;\n    const livenessMs = Duration.toMillis(\n      options?.livenessInterval ?? '5 seconds',\n    );\n    yield* controllerComing({\n      enabled: info.enabled,\n      container,\n      graceMs: livenessMs,\n    });\n    const skew = makeSkewState();\n    const protocol = yield* RpcClient.makeProtocolWorker({ size: 1 }).pipe(\n      Effect.provideService(\n        Worker.WorkerPlatform,\n        makeClientPlatform({\n          buildId,\n          skew,\n          livenessMs,\n        }),\n      ),\n      Effect.provideService(Worker.Spawner, () => container),\n    );\n    const client: Client<Rpcs> = yield* RpcClient.make(group).pipe(\n      Effect.provideService(\n        RpcClient.Protocol,\n        withVersionSkew(protocol, skew),\n      ),\n    );\n    return client;\n  });\n\n/**\n * One page's Worker RPC connection. Every message goes through the current\n * controller, carrying the page's Build ID (from the meta tag `pwaHead()`\n * renders). On a first visit, calls wait for the worker to take control.\n * `make` fails at once when no worker ever will: the PWA is off in this\n * build, or a hard reload left the page uncontrolled.\n *\n * - Version Skew: a worker of another Build ID refuses the connection, and\n *   calls fail with `VersionSkew` until a new controller takes over. The app\n *   may answer it with `usePwa().checkForUpdate`.\n * - Worker restart: the browser may stop the worker at any time. A call made\n *   while nothing was in flight wakes the new worker and succeeds. Calls in\n *   flight then fail with `RpcClientError` (found at the next message, or\n *   within the liveness interval), and the Worker Client connects again on its\n *   own. A stream is never resumed where it stopped: Subscription Restart\n *   means subscribing again (e.g. `Stream.retry`), and the handler starts\n *   over from the current state, so it must emit everything a fresh\n *   subscriber needs.\n */\nexport const WorkerClient = {\n  make,\n  layer: <Id, Rpcs extends Rpc.Any>(\n    tag: Context.Key<Id, Client<Rpcs>>,\n    group: RpcGroup.RpcGroup<Rpcs>,\n    options?: Options,\n  ): Layer.Layer<Id, WorkerError, Rpc.MiddlewareClient<Rpcs>> =>\n    Layer.effect(tag)(make(group, options)),\n};\n"],"mappings":";;;;;;;;;;;AAqCA,MAAM,QACJ,OACA,YAMA,OAAO,IAAI,aAAa;CACtB,MAAM,UAAU,OAAO;CACvB,MAAM,YAAY,OAAO;CACzB,MAAM,aAAa,SAAS,SAC1B,SAAS,oBAAoB,WAC/B;CACA,OAAO,iBAAiB;EACtB,SAAS,KAAK;EACd;EACA,SAAS;CACX,CAAC;CACD,MAAM,OAAO,cAAc;CAC3B,MAAM,WAAW,OAAO,UAAU,mBAAmB,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,KAChE,OAAO,eACL,OAAO,gBACP,mBAAmB;EACjB;EACA;EACA;CACF,CAAC,CACH,GACA,OAAO,eAAe,OAAO,eAAe,SAAS,CACvD;CAOA,OAAO,OAN6B,UAAU,KAAK,KAAK,CAAC,CAAC,KACxD,OAAO,eACL,UAAU,UACV,gBAAgB,UAAU,IAAI,CAChC,CACF;AAEF,CAAC;;;;;;;;;;;;;;;;;;;;AAqBH,MAAa,eAAe;CAC1B;CACA,QACE,KACA,OACA,YAEA,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,OAAO,OAAO,CAAC;AAC1C"}

package/dist/pwa/rpc/client/index.d.ts

@@ -0,0 +1,3 @@
+import { VersionSkew } from "../handshake/handshake.js";
+import { WorkerClient } from "./client.js";
+export { VersionSkew, WorkerClient };

package/dist/pwa/rpc/client/index.js

@@ -0,0 +1,3 @@
+import { VersionSkew } from "../handshake/handshake.js";
+import { WorkerClient } from "./client.js";
+export { VersionSkew, WorkerClient };