@kestack/web-platform 0.0.0-stage → 0.0.1

package/dist/pwa/rpc/client/page-environment.d.ts

@@ -0,0 +1,25 @@
+import { BuildId } from "../../shared/build/build.js";
+import "../../shared/build/index.js";
+import * as Effect from "effect/Effect";
+import { WorkerError } from "effect/workers/WorkerError";
+//#region src/pwa/rpc/client/page-environment.d.ts
+/** The page's Build ID, from the meta tag `pwaHead()` renders. */
+export declare const pageBuildId: Effect.Effect<BuildId, WorkerError>;
+/** `navigator.serviceWorker`, where the browser offers it. */
+export declare const serviceWorkerContainer: Effect.Effect<ServiceWorkerContainer, WorkerError>;
+/**
+ * Fails at once when no service worker will ever control this page, instead
+ * of letting calls wait for a controller forever:
+ * - the PWA is off in this build (the Kill Switch, or `vite dev` without
+ *   `dev: true`), so nothing registers;
+ * - an active worker exists but does not control the page after `graceMs`
+ *   (a hard reload bypasses it until the next normal load).
+ * On a first visit (nothing active yet) calls wait for the worker to take over.
+ */
+export declare const controllerComing: (options: {
+  readonly enabled: boolean;
+  readonly container: ServiceWorkerContainer;
+  readonly graceMs: number;
+}) => Effect.Effect<void, WorkerError>;
+//#endregion
+//# sourceMappingURL=page-environment.d.ts.map

package/dist/pwa/rpc/client/page-environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-environment.d.ts","names":[],"sources":["../../../../src/pwa/rpc/client/page-environment.ts"],"mappings":";;;;;;qBAYa,aAAa,OAAO,OAAO,SAAS;;qBAkBpC,wBAAwB,OAAO,OAC1C,wBACA;;;;;;;;;;qBAqBW,mBAAgB;WAClB;WACA,WAAW;WACX;MACP,OAAO,aAAa"}

package/dist/pwa/rpc/client/page-environment.js

@@ -0,0 +1,46 @@
+import { BUILD_ID_META_NAME, BuildId } from "../../shared/build/build.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import { WorkerError, WorkerSpawnError } from "effect/workers/WorkerError";
+//#region src/pwa/rpc/client/page-environment.ts
+const spawnError = (message) => new WorkerError({ reason: new WorkerSpawnError({ message }) });
+const decodeBuildId = Schema.decodeUnknownOption(BuildId);
+/** The page's Build ID, from the meta tag `pwaHead()` renders. */
+const pageBuildId = Effect.suspend(() => {
+	const content = globalThis.document?.querySelector(`meta[name="${BUILD_ID_META_NAME}"]`)?.getAttribute("content");
+	return Option.match(decodeBuildId(content), {
+		onSome: Effect.succeed,
+		onNone: () => Effect.fail(spawnError(`Worker RPC needs the Build ID meta tag (${BUILD_ID_META_NAME}); render pwaHead() in the document head`))
+	});
+});
+/** `navigator.serviceWorker`, where the browser offers it. */
+const serviceWorkerContainer = Effect.suspend(() => {
+	const container = globalThis.navigator?.serviceWorker;
+	return container === void 0 ? Effect.fail(spawnError("Worker RPC needs service workers (a secure context in a supporting browser)")) : Effect.succeed(container);
+});
+/**
+* Fails at once when no service worker will ever control this page, instead
+* of letting calls wait for a controller forever:
+* - the PWA is off in this build (the Kill Switch, or `vite dev` without
+*   `dev: true`), so nothing registers;
+* - an active worker exists but does not control the page after `graceMs`
+*   (a hard reload bypasses it until the next normal load).
+* On a first visit (nothing active yet) calls wait for the worker to take over.
+*/
+const controllerComing = (options) => Effect.gen(function* () {
+	const { enabled, container, graceMs } = options;
+	if (!enabled) return yield* Effect.fail(spawnError("Worker RPC has no service worker: the PWA is off in this build (the Kill Switch, or vite dev without dev: true)"));
+	if (container.controller !== null) return;
+	const registration = yield* Effect.tryPromise(() => container.getRegistration()).pipe(Effect.orElseSucceed(() => void 0));
+	if ((registration?.active ?? null) === null || registration?.installing !== null) return;
+	if (!(yield* Effect.callback((resume) => {
+		const onChange = () => resume(Effect.succeed(true));
+		container.addEventListener("controllerchange", onChange);
+		return Effect.sync(() => container.removeEventListener("controllerchange", onChange));
+	}).pipe(Effect.timeoutOption(graceMs), Effect.map(Option.isSome))) && container.controller === null) return yield* Effect.fail(spawnError("No service worker controls this page (a hard reload bypasses it); reload the page normally"));
+});
+//#endregion
+export { controllerComing, pageBuildId, serviceWorkerContainer };
+
+//# sourceMappingURL=page-environment.js.map

package/dist/pwa/rpc/client/page-environment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-environment.js","names":[],"sources":["../../../../src/pwa/rpc/client/page-environment.ts"],"sourcesContent":["import * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport { WorkerError, WorkerSpawnError } from 'effect/workers/WorkerError';\nimport { BUILD_ID_META_NAME, BuildId } from '../../shared/build/index.js';\n\nconst spawnError = (message: string) =>\n  new WorkerError({ reason: new WorkerSpawnError({ message }) });\n\nconst decodeBuildId = Schema.decodeUnknownOption(BuildId);\n\n/** The page's Build ID, from the meta tag `pwaHead()` renders. */\nexport const pageBuildId: Effect.Effect<BuildId, WorkerError> = Effect.suspend(\n  () => {\n    const content = globalThis.document\n      ?.querySelector<HTMLMetaElement>(`meta[name=\"${BUILD_ID_META_NAME}\"]`)\n      ?.getAttribute('content');\n    return Option.match(decodeBuildId(content), {\n      onSome: Effect.succeed,\n      onNone: () =>\n        Effect.fail(\n          spawnError(\n            `Worker RPC needs the Build ID meta tag (${BUILD_ID_META_NAME}); render pwaHead() in the document head`,\n          ),\n        ),\n    });\n  },\n);\n\n/** `navigator.serviceWorker`, where the browser offers it. */\nexport const serviceWorkerContainer: Effect.Effect<\n  ServiceWorkerContainer,\n  WorkerError\n> = Effect.suspend(() => {\n  const container = globalThis.navigator?.serviceWorker;\n  return container === undefined\n    ? Effect.fail(\n        spawnError(\n          'Worker RPC needs service workers (a secure context in a supporting browser)',\n        ),\n      )\n    : Effect.succeed(container);\n});\n\n/**\n * Fails at once when no service worker will ever control this page, instead\n * of letting calls wait for a controller forever:\n * - the PWA is off in this build (the Kill Switch, or `vite dev` without\n *   `dev: true`), so nothing registers;\n * - an active worker exists but does not control the page after `graceMs`\n *   (a hard reload bypasses it until the next normal load).\n * On a first visit (nothing active yet) calls wait for the worker to take over.\n */\nexport const controllerComing = (options: {\n  readonly enabled: boolean;\n  readonly container: ServiceWorkerContainer;\n  readonly graceMs: number;\n}): Effect.Effect<void, WorkerError> =>\n  Effect.gen(function* () {\n    const { enabled, container, graceMs } = options;\n    if (!enabled) {\n      return yield* Effect.fail(\n        spawnError(\n          'Worker RPC has no service worker: the PWA is off in this build (the Kill Switch, or vite dev without dev: true)',\n        ),\n      );\n    }\n    if (container.controller !== null) return;\n    const registration = yield* Effect.tryPromise(() =>\n      container.getRegistration(),\n    ).pipe(Effect.orElseSucceed(() => undefined));\n    const active = registration?.active ?? null;\n    if (active === null || registration?.installing !== null) return;\n    const controlled = yield* Effect.callback<boolean>((resume) => {\n      const onChange = () => resume(Effect.succeed(true));\n      container.addEventListener('controllerchange', onChange);\n      return Effect.sync(() =>\n        container.removeEventListener('controllerchange', onChange),\n      );\n    }).pipe(Effect.timeoutOption(graceMs), Effect.map(Option.isSome));\n    if (!controlled && container.controller === null) {\n      return yield* Effect.fail(\n        spawnError(\n          'No service worker controls this page (a hard reload bypasses it); reload the page normally',\n        ),\n      );\n    }\n  });\n"],"mappings":";;;;;;AAMA,MAAM,cAAc,YAClB,IAAI,YAAY,EAAE,QAAQ,IAAI,iBAAiB,EAAE,QAAQ,CAAC,EAAE,CAAC;AAE/D,MAAM,gBAAgB,OAAO,oBAAoB,OAAO;;AAGxD,MAAa,cAAmD,OAAO,cAC/D;CACJ,MAAM,UAAU,WAAW,UACvB,cAA+B,cAAc,mBAAmB,GAAG,CAAC,EACpE,aAAa,SAAS;CAC1B,OAAO,OAAO,MAAM,cAAc,OAAO,GAAG;EAC1C,QAAQ,OAAO;EACf,cACE,OAAO,KACL,WACE,2CAA2C,mBAAmB,yCAChE,CACF;CACJ,CAAC;AACH,CACF;;AAGA,MAAa,yBAGT,OAAO,cAAc;CACvB,MAAM,YAAY,WAAW,WAAW;CACxC,OAAO,cAAc,KAAA,IACjB,OAAO,KACL,WACE,6EACF,CACF,IACA,OAAO,QAAQ,SAAS;AAC9B,CAAC;;;;;;;;;;AAWD,MAAa,oBAAoB,YAK/B,OAAO,IAAI,aAAa;CACtB,MAAM,EAAE,SAAS,WAAW,YAAY;CACxC,IAAI,CAAC,SACH,OAAO,OAAO,OAAO,KACnB,WACE,iHACF,CACF;CAEF,IAAI,UAAU,eAAe,MAAM;CACnC,MAAM,eAAe,OAAO,OAAO,iBACjC,UAAU,gBAAgB,CAC5B,CAAC,CAAC,KAAK,OAAO,oBAAoB,KAAA,CAAS,CAAC;CAE5C,KADe,cAAc,UAAU,UACxB,QAAQ,cAAc,eAAe,MAAM;CAQ1D,IAAI,EAAC,OAPqB,OAAO,UAAmB,WAAW;EAC7D,MAAM,iBAAiB,OAAO,OAAO,QAAQ,IAAI,CAAC;EAClD,UAAU,iBAAiB,oBAAoB,QAAQ;EACvD,OAAO,OAAO,WACZ,UAAU,oBAAoB,oBAAoB,QAAQ,CAC5D;CACF,CAAC,CAAC,CAAC,KAAK,OAAO,cAAc,OAAO,GAAG,OAAO,IAAI,OAAO,MAAM,CAAC,MAC7C,UAAU,eAAe,MAC1C,OAAO,OAAO,OAAO,KACnB,WACE,4FACF,CACF;AAEJ,CAAC"}

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

@@ -0,0 +1,26 @@
+import { BuildId } from "../../shared/build/build.js";
+import "../../shared/build/index.js";
+import { SkewState } from "./version-skew.js";
+import * as Effect from "effect/Effect";
+import * as Worker from "effect/workers/Worker";
+import { WorkerError } from "effect/workers/WorkerError";
+//#region src/pwa/rpc/client/platform.d.ts
+interface Options {
+  readonly buildId: BuildId;
+  /** How often to check a silent worker, and how long to wait for READY. */
+  readonly livenessMs: number;
+  readonly skew: SkewState;
+}
+/**
+ * Effect's `WorkerPlatform` for a Worker Client: every frame goes through
+ * `navigator.serviceWorker.controller.postMessage`, which wakes a stopped
+ * worker, and replies arrive on `navigator.serviceWorker`. One spawned
+ * "worker" is one connection; it fails, and Effect's worker protocol opens a
+ * new one, when the worker answers VERSION_SKEW or UNKNOWN_CONNECTION, when
+ * the controller changes, or when no READY comes within the liveness interval.
+ */
+export declare const makeClientPlatform: (options: Options) => {
+  readonly spawn: <O = unknown, I = unknown>(id: number) => Effect.Effect<Worker.Worker<O, I>, WorkerError, Worker.Spawner>;
+};
+//#endregion
+//# sourceMappingURL=platform.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","names":[],"sources":["../../../../src/pwa/rpc/client/platform.ts"],"mappings":";;;;;;;UAqBU;WACC,SAAS;;WAET;WACA,MAAM;;;;;;;;;;qBAqFJ,qBAAkB,SAAa"}

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

@@ -0,0 +1,144 @@
+import { RPC_ENVELOPE_KEY, VersionSkew, makeInFlight, matchWorkerEnvelope } from "../handshake/handshake.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Worker from "effect/workers/Worker";
+import * as Deferred from "effect/Deferred";
+import * as Scope from "effect/Scope";
+import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/workers/WorkerError";
+//#region src/pwa/rpc/client/platform.ts
+/**
+* Resolves with the controller to connect to. A controller that just
+* reported Version Skew is skipped until another takes its place.
+*/
+const awaitController = (container, skip) => Effect.callback((resume) => {
+	const check = () => {
+		const controller = container.controller;
+		if (controller === null || controller === skip) return false;
+		resume(Effect.succeed(controller));
+		return true;
+	};
+	if (check()) return;
+	const onChange = () => {
+		if (check()) container.removeEventListener("controllerchange", onChange);
+	};
+	container.addEventListener("controllerchange", onChange);
+	return Effect.sync(() => container.removeEventListener("controllerchange", onChange));
+});
+/** One connection to one controller: what Effect's worker client sends to. */
+const makePort = (controller, buildId) => {
+	const connectionId = crypto.randomUUID();
+	const inFlight = makeInFlight();
+	let closed = false;
+	const post = (body, transfers = []) => {
+		if (closed) return;
+		const envelope = {
+			[RPC_ENVELOPE_KEY]: 1,
+			buildId,
+			connectionId,
+			...body
+		};
+		controller.postMessage(envelope, transfers);
+	};
+	return {
+		controller,
+		connectionId,
+		inFlight,
+		post,
+		/** Stops all traffic; the connection is dead. */
+		close() {
+			closed = true;
+			inFlight.clear();
+		},
+		postMessage(frame, transfers) {
+			if (frame[0] === 1) return post({ type: "CLOSE" });
+			const open = inFlight.size;
+			inFlight.request(frame[1]);
+			post({
+				type: "MESSAGE",
+				message: frame[1],
+				open
+			}, transfers);
+		}
+	};
+};
+const lost = (message) => new WorkerError({ reason: new WorkerReceiveError({ message }) });
+/**
+* Effect's `WorkerPlatform` for a Worker Client: every frame goes through
+* `navigator.serviceWorker.controller.postMessage`, which wakes a stopped
+* worker, and replies arrive on `navigator.serviceWorker`. One spawned
+* "worker" is one connection; it fails, and Effect's worker protocol opens a
+* new one, when the worker answers VERSION_SKEW or UNKNOWN_CONNECTION, when
+* the controller changes, or when no READY comes within the liveness interval.
+*/
+const makeClientPlatform = (options) => Worker.makePlatform()({
+	setup: ({ worker: container, scope }) => Effect.gen(function* () {
+		const controller = yield* awaitController(container, options.skew.controller);
+		const port = makePort(controller, options.buildId);
+		yield* Scope.addFinalizer(scope, Effect.sync(() => {
+			port.postMessage([1]);
+			port.close();
+		}));
+		return Object.assign(port, { container });
+	}),
+	listen: ({ port, emit, deferred, scope }) => Effect.suspend(() => {
+		const { container } = port;
+		let ready = false;
+		const openReady = () => {
+			if (ready) return;
+			ready = true;
+			emit([0]);
+		};
+		const fail = (error) => {
+			port.close();
+			openReady();
+			Deferred.doneUnsafe(deferred, Effect.fail(error));
+		};
+		const onMessage = (event) => {
+			const found = matchWorkerEnvelope(event.data);
+			if (Option.isNone(found)) return;
+			const envelope = found.value;
+			if (envelope.connectionId !== port.connectionId) return;
+			switch (envelope.type) {
+				case "READY":
+					options.skew.clear();
+					return openReady();
+				case "MESSAGE":
+					port.inFlight.response(envelope.message);
+					return emit([1, envelope.message]);
+				case "VERSION_SKEW": {
+					const skew = new VersionSkew({
+						pageBuildId: options.buildId,
+						workerBuildId: envelope.buildId
+					});
+					options.skew.set(skew, port.controller);
+					return fail(new WorkerError({ reason: new WorkerSpawnError({
+						message: "Version Skew: the page and the service worker belong to different Build IDs",
+						cause: skew
+					}) }));
+				}
+				case "UNKNOWN_CONNECTION": return fail(lost("The Worker Server no longer knows this Worker Client; the service worker was restarted"));
+			}
+		};
+		const onControllerChange = () => fail(lost("The service worker controlling this page changed"));
+		const connectTimeout = setTimeout(() => {
+			if (!ready) fail(lost("No Worker Server answered the handshake"));
+		}, options.livenessMs);
+		const liveness = setInterval(() => {
+			if (ready && port.inFlight.size > 0) port.post({ type: "PING" });
+		}, options.livenessMs);
+		container.addEventListener("message", onMessage);
+		container.addEventListener("controllerchange", onControllerChange);
+		container.startMessages?.();
+		port.post({ type: "CONNECT" });
+		return Scope.addFinalizer(scope, Effect.sync(() => {
+			clearTimeout(connectTimeout);
+			clearInterval(liveness);
+			container.removeEventListener("message", onMessage);
+			container.removeEventListener("controllerchange", onControllerChange);
+		}));
+	})
+});
+//#endregion
+export { makeClientPlatform };
+
+//# sourceMappingURL=platform.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"platform.js","names":[],"sources":["../../../../src/pwa/rpc/client/platform.ts"],"sourcesContent":["import * as Deferred from 'effect/Deferred';\nimport * as Effect from 'effect/Effect';\nimport * as Option from 'effect/Option';\nimport * as Scope from 'effect/Scope';\nimport * as Worker from 'effect/workers/Worker';\nimport {\n  WorkerError,\n  WorkerReceiveError,\n  WorkerSpawnError,\n} from 'effect/workers/WorkerError';\nimport type { PlatformMessage } from 'effect/workers/WorkerRunner';\nimport type { BuildId } from '../../shared/build/index.js';\nimport {\n  makeInFlight,\n  matchWorkerEnvelope,\n  RPC_ENVELOPE_KEY,\n  type ClientEnvelope,\n  VersionSkew,\n} from '../handshake/index.js';\nimport type { SkewState } from './version-skew.js';\n\ninterface Options {\n  readonly buildId: BuildId;\n  /** How often to check a silent worker, and how long to wait for READY. */\n  readonly livenessMs: number;\n  readonly skew: SkewState;\n}\n\n/**\n * Resolves with the controller to connect to. A controller that just\n * reported Version Skew is skipped until another takes its place.\n */\nconst awaitController = (\n  container: ServiceWorkerContainer,\n  skip?: ServiceWorker,\n) =>\n  Effect.callback<ServiceWorker>((resume) => {\n    const check = () => {\n      const controller = container.controller;\n      if (controller === null || controller === skip) return false;\n      resume(Effect.succeed(controller));\n      return true;\n    };\n    if (check()) return;\n    const onChange = () => {\n      if (check()) container.removeEventListener('controllerchange', onChange);\n    };\n    container.addEventListener('controllerchange', onChange);\n    return Effect.sync(() =>\n      container.removeEventListener('controllerchange', onChange),\n    );\n  });\n\n/** One connection to one controller: what Effect's worker client sends to. */\nconst makePort = (controller: ServiceWorker, buildId: BuildId) => {\n  const connectionId = crypto.randomUUID();\n  const inFlight = makeInFlight();\n  let closed = false;\n  const post = (\n    body:\n      | { readonly type: 'CONNECT' | 'CLOSE' | 'PING' }\n      | {\n          readonly type: 'MESSAGE';\n          readonly message: unknown;\n          readonly open: number;\n        },\n    transfers: ReadonlyArray<unknown> = [],\n  ) => {\n    if (closed) return;\n    const envelope: ClientEnvelope = {\n      [RPC_ENVELOPE_KEY]: 1,\n      buildId,\n      connectionId,\n      ...body,\n    };\n    controller.postMessage(envelope, transfers as Transferable[]);\n  };\n  return {\n    controller,\n    connectionId,\n    inFlight,\n    post,\n    /** Stops all traffic; the connection is dead. */\n    close() {\n      closed = true;\n      inFlight.clear();\n    },\n    postMessage(\n      frame: PlatformMessage<unknown>,\n      transfers?: ReadonlyArray<unknown>,\n    ) {\n      if (frame[0] === 1) return post({ type: 'CLOSE' });\n      const open = inFlight.size;\n      inFlight.request(frame[1]);\n      post({ type: 'MESSAGE', message: frame[1], open }, transfers);\n    },\n  };\n};\n\nconst lost = (message: string) =>\n  new WorkerError({ reason: new WorkerReceiveError({ message }) });\n\n/**\n * Effect's `WorkerPlatform` for a Worker Client: every frame goes through\n * `navigator.serviceWorker.controller.postMessage`, which wakes a stopped\n * worker, and replies arrive on `navigator.serviceWorker`. One spawned\n * \"worker\" is one connection; it fails, and Effect's worker protocol opens a\n * new one, when the worker answers VERSION_SKEW or UNKNOWN_CONNECTION, when\n * the controller changes, or when no READY comes within the liveness interval.\n */\nexport const makeClientPlatform = (options: Options) =>\n  Worker.makePlatform<ServiceWorkerContainer>()({\n    setup: ({ worker: container, scope }) =>\n      Effect.gen(function* () {\n        const controller = yield* awaitController(\n          container,\n          options.skew.controller,\n        );\n        const port = makePort(controller, options.buildId);\n        yield* Scope.addFinalizer(\n          scope,\n          Effect.sync(() => {\n            port.postMessage([1]);\n            port.close();\n          }),\n        );\n        return Object.assign(port, { container });\n      }),\n    listen: ({ port, emit, deferred, scope }) =>\n      Effect.suspend(() => {\n        const { container } = port;\n        let ready = false;\n        const openReady = () => {\n          if (ready) return;\n          ready = true;\n          emit([0]);\n        };\n        // Effect's worker client waits for ready before it watches for\n        // failure, so a connection that fails first still reports ready.\n        const fail = (error: WorkerError) => {\n          port.close();\n          openReady();\n          Deferred.doneUnsafe(deferred, Effect.fail(error));\n        };\n\n        const onMessage = (event: MessageEvent) => {\n          const found = matchWorkerEnvelope(event.data);\n          if (Option.isNone(found)) return;\n          const envelope = found.value;\n          if (envelope.connectionId !== port.connectionId) return;\n          switch (envelope.type) {\n            case 'READY':\n              options.skew.clear();\n              return openReady();\n            case 'MESSAGE':\n              port.inFlight.response(envelope.message);\n              return emit([1, envelope.message]);\n            case 'VERSION_SKEW': {\n              const skew = new VersionSkew({\n                pageBuildId: options.buildId,\n                workerBuildId: envelope.buildId,\n              });\n              options.skew.set(skew, port.controller);\n              return fail(\n                new WorkerError({\n                  reason: new WorkerSpawnError({\n                    message:\n                      'Version Skew: the page and the service worker belong to different Build IDs',\n                    cause: skew,\n                  }),\n                }),\n              );\n            }\n            case 'UNKNOWN_CONNECTION':\n              return fail(\n                lost(\n                  'The Worker Server no longer knows this Worker Client; the service worker was restarted',\n                ),\n              );\n          }\n        };\n        const onControllerChange = () =>\n          fail(lost('The service worker controlling this page changed'));\n\n        const connectTimeout = setTimeout(() => {\n          if (!ready) fail(lost('No Worker Server answered the handshake'));\n        }, options.livenessMs);\n        // A stopped worker cannot tell the page it lost its calls. While calls\n        // are in flight, a PING wakes it; a restarted worker answers\n        // UNKNOWN_CONNECTION.\n        const liveness = setInterval(() => {\n          if (ready && port.inFlight.size > 0) port.post({ type: 'PING' });\n        }, options.livenessMs);\n\n        container.addEventListener('message', onMessage);\n        container.addEventListener('controllerchange', onControllerChange);\n        container.startMessages?.();\n        port.post({ type: 'CONNECT' });\n\n        return Scope.addFinalizer(\n          scope,\n          Effect.sync(() => {\n            clearTimeout(connectTimeout);\n            clearInterval(liveness);\n            container.removeEventListener('message', onMessage);\n            container.removeEventListener(\n              'controllerchange',\n              onControllerChange,\n            );\n          }),\n        );\n      }),\n  });\n"],"mappings":"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"}

package/dist/pwa/rpc/client/version-skew.d.ts

@@ -0,0 +1,24 @@
+import { VersionSkew } from "../handshake/handshake.js";
+import "../handshake/index.js";
+import * as RpcClient from "effect/rpc/RpcClient";
+//#region src/pwa/rpc/client/version-skew.d.ts
+/**
+ * The last handshake's Version Skew, if any, and the controller that
+ * reported it. Cleared by the next READY.
+ */
+export declare const makeSkewState: () => {
+  readonly skew: VersionSkew | undefined;
+  readonly controller: ServiceWorker | undefined;
+  set(skew: VersionSkew, controller: ServiceWorker): void;
+  clear(): void;
+};
+export type SkewState = ReturnType<typeof makeSkewState>;
+/**
+ * Surfaces Version Skew to calls as the typed `VersionSkew` error instead of
+ * an `RpcClientError`. The platform reports skew as a failed connection whose
+ * cause is the `VersionSkew`; this unwraps it. While skew is known, new calls
+ * fail at once instead of waiting for a connection that cannot open.
+ */
+export declare const withVersionSkew: (protocol: RpcClient.Protocol['Service'], state: SkewState) => RpcClient.Protocol['Service'];
+//#endregion
+//# sourceMappingURL=version-skew.d.ts.map

package/dist/pwa/rpc/client/version-skew.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-skew.d.ts","names":[],"sources":["../../../../src/pwa/rpc/client/version-skew.ts"],"mappings":";;;;;;;;qBASa;WAKL,MAAI;WAGJ,YAAU;EAGd,IAAG,MAAO,aAAW,YAAc;EAGnC;;YAKQ,YAAY,kBAAkB;;;;;;;qBAc7B,kBAAe,UAChB,UAAU,qBAAmB,OAChC,cACN,UAAU"}

package/dist/pwa/rpc/client/version-skew.js

@@ -0,0 +1,63 @@
+import { VersionSkew } from "../handshake/handshake.js";
+//#region src/pwa/rpc/client/version-skew.ts
+/**
+* The last handshake's Version Skew, if any, and the controller that
+* reported it. Cleared by the next READY.
+*/
+const makeSkewState = () => {
+	let current;
+	return {
+		get skew() {
+			return current?.skew;
+		},
+		get controller() {
+			return current?.controller;
+		},
+		set(skew, controller) {
+			current = {
+				skew,
+				controller
+			};
+		},
+		clear() {
+			current = void 0;
+		}
+	};
+};
+const skewOf = (message) => {
+	if (message._tag !== "ClientProtocolError") return void 0;
+	const cause = message.error.reason.cause;
+	return cause instanceof VersionSkew ? cause : void 0;
+};
+/**
+* Surfaces Version Skew to calls as the typed `VersionSkew` error instead of
+* an `RpcClientError`. The platform reports skew as a failed connection whose
+* cause is the `VersionSkew`; this unwraps it. While skew is known, new calls
+* fail at once instead of waiting for a connection that cannot open.
+*/
+const withVersionSkew = (protocol, state) => {
+	const writers = /* @__PURE__ */ new Map();
+	const failWith = (skew) => ({
+		_tag: "ClientProtocolError",
+		error: skew
+	});
+	return {
+		...protocol,
+		run: (clientId, write) => {
+			writers.set(clientId, write);
+			return protocol.run(clientId, (message) => {
+				const skew = skewOf(message);
+				return write(skew ? failWith(skew) : message);
+			});
+		},
+		send: (clientId, request, transferables) => {
+			const skew = state.skew;
+			const write = writers.get(clientId);
+			return skew && write && request._tag === "Request" ? write(failWith(skew)) : protocol.send(clientId, request, transferables);
+		}
+	};
+};
+//#endregion
+export { makeSkewState, withVersionSkew };
+
+//# sourceMappingURL=version-skew.js.map

package/dist/pwa/rpc/client/version-skew.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-skew.js","names":[],"sources":["../../../../src/pwa/rpc/client/version-skew.ts"],"sourcesContent":["import * as Effect from 'effect/Effect';\nimport type * as RpcClient from 'effect/rpc/RpcClient';\nimport type { FromServerEncoded } from 'effect/rpc/RpcMessage';\nimport { VersionSkew } from '../handshake/index.js';\n\n/**\n * The last handshake's Version Skew, if any, and the controller that\n * reported it. Cleared by the next READY.\n */\nexport const makeSkewState = () => {\n  let current:\n    | { readonly skew: VersionSkew; readonly controller: ServiceWorker }\n    | undefined;\n  return {\n    get skew() {\n      return current?.skew;\n    },\n    get controller() {\n      return current?.controller;\n    },\n    set(skew: VersionSkew, controller: ServiceWorker) {\n      current = { skew, controller };\n    },\n    clear() {\n      current = undefined;\n    },\n  };\n};\nexport type SkewState = ReturnType<typeof makeSkewState>;\n\nconst skewOf = (message: FromServerEncoded): VersionSkew | undefined => {\n  if (message._tag !== 'ClientProtocolError') return undefined;\n  const cause: unknown = (message.error.reason as { cause?: unknown }).cause;\n  return cause instanceof VersionSkew ? cause : undefined;\n};\n\n/**\n * Surfaces Version Skew to calls as the typed `VersionSkew` error instead of\n * an `RpcClientError`. The platform reports skew as a failed connection whose\n * cause is the `VersionSkew`; this unwraps it. While skew is known, new calls\n * fail at once instead of waiting for a connection that cannot open.\n */\nexport const withVersionSkew = (\n  protocol: RpcClient.Protocol['Service'],\n  state: SkewState,\n): RpcClient.Protocol['Service'] => {\n  const writers = new Map<\n    number,\n    (message: FromServerEncoded) => Effect.Effect<void>\n  >();\n  const failWith = (skew: VersionSkew): FromServerEncoded =>\n    ({ _tag: 'ClientProtocolError', error: skew }) as never;\n\n  return {\n    ...protocol,\n    run: (clientId, write) => {\n      writers.set(clientId, write);\n      return protocol.run(clientId, (message) => {\n        const skew = skewOf(message);\n        return write(skew ? failWith(skew) : message);\n      });\n    },\n    send: (clientId, request, transferables) => {\n      const skew = state.skew;\n      const write = writers.get(clientId);\n      return skew && write && request._tag === 'Request'\n        ? write(failWith(skew))\n        : protocol.send(clientId, request, transferables);\n    },\n  };\n};\n"],"mappings":";;;;;;AASA,MAAa,sBAAsB;CACjC,IAAI;CAGJ,OAAO;EACL,IAAI,OAAO;GACT,OAAO,SAAS;EAClB;EACA,IAAI,aAAa;GACf,OAAO,SAAS;EAClB;EACA,IAAI,MAAmB,YAA2B;GAChD,UAAU;IAAE;IAAM;GAAW;EAC/B;EACA,QAAQ;GACN,UAAU,KAAA;EACZ;CACF;AACF;AAGA,MAAM,UAAU,YAAwD;CACtE,IAAI,QAAQ,SAAS,uBAAuB,OAAO,KAAA;CACnD,MAAM,QAAkB,QAAQ,MAAM,OAA+B;CACrE,OAAO,iBAAiB,cAAc,QAAQ,KAAA;AAChD;;;;;;;AAQA,MAAa,mBACX,UACA,UACkC;CAClC,MAAM,0BAAU,IAAI,IAGlB;CACF,MAAM,YAAY,UACf;EAAE,MAAM;EAAuB,OAAO;CAAK;CAE9C,OAAO;EACL,GAAG;EACH,MAAM,UAAU,UAAU;GACxB,QAAQ,IAAI,UAAU,KAAK;GAC3B,OAAO,SAAS,IAAI,WAAW,YAAY;IACzC,MAAM,OAAO,OAAO,OAAO;IAC3B,OAAO,MAAM,OAAO,SAAS,IAAI,IAAI,OAAO;GAC9C,CAAC;EACH;EACA,OAAO,UAAU,SAAS,kBAAkB;GAC1C,MAAM,OAAO,MAAM;GACnB,MAAM,QAAQ,QAAQ,IAAI,QAAQ;GAClC,OAAO,QAAQ,SAAS,QAAQ,SAAS,YACrC,MAAM,SAAS,IAAI,CAAC,IACpB,SAAS,KAAK,UAAU,SAAS,aAAa;EACpD;CACF;AACF"}

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

@@ -0,0 +1,74 @@
+import { BuildId } from "../../shared/build/build.js";
+import "../../shared/build/index.js";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+//#region src/pwa/rpc/handshake/handshake.d.ts
+/**
+ * Worker RPC's own envelope, distinct from the command key so each
+ * listener ignores the other's traffic. Every envelope names its sender's
+ * Build ID and the Worker Client connection it belongs to.
+ *
+ * A connection opens with CONNECT, answered by READY or VERSION_SKEW. A
+ * worker that does not know the connection (it was stopped and started
+ * again) adopts it when the message is a new Request and the page has no
+ * other call open (`open: 0`), since nothing was lost; otherwise it answers
+ * UNKNOWN_CONNECTION, and the page opens a new one.
+ */
+export declare const RPC_ENVELOPE_KEY = "__pwaToolkitRpc";
+/** Worker Client → Worker Server, via `navigator.serviceWorker.controller.postMessage`. */
+export declare const ClientEnvelope: Schema.Union<readonly [Schema.Struct<{
+  readonly __pwaToolkitRpc: Schema.Literal<1>;
+  readonly buildId: Schema.brand<Schema.NonEmptyString, "BuildId">;
+  readonly connectionId: Schema.String;
+  readonly type: Schema.Literals<readonly ["CONNECT", "CLOSE", "PING"]>;
+}>, Schema.Struct<{
+  readonly __pwaToolkitRpc: Schema.Literal<1>;
+  readonly buildId: Schema.brand<Schema.NonEmptyString, "BuildId">;
+  readonly connectionId: Schema.String;
+  readonly type: Schema.Literal<"MESSAGE">;
+  readonly message: Schema.Unknown;
+  /** Calls the page had open on this connection before this message. */
+  readonly open: Schema.Number;
+}>]>;
+export type ClientEnvelope = typeof ClientEnvelope.Type;
+/** Worker Server → Worker Client, via the page's `Client.postMessage`. */
+export declare const WorkerEnvelope: Schema.Union<readonly [Schema.Struct<{
+  readonly __pwaToolkitRpc: Schema.Literal<1>;
+  readonly buildId: Schema.brand<Schema.NonEmptyString, "BuildId">;
+  readonly connectionId: Schema.String;
+  readonly type: Schema.Literals<readonly ["READY", "VERSION_SKEW", "UNKNOWN_CONNECTION"]>;
+}>, Schema.Struct<{
+  readonly __pwaToolkitRpc: Schema.Literal<1>;
+  readonly buildId: Schema.brand<Schema.NonEmptyString, "BuildId">;
+  readonly connectionId: Schema.String;
+  readonly type: Schema.Literal<"MESSAGE">;
+  readonly message: Schema.Unknown;
+}>]>;
+export type WorkerEnvelope = typeof WorkerEnvelope.Type;
+declare const VersionSkew_base: Schema.Class<VersionSkew, Schema.TaggedStruct<"VersionSkew", {
+  readonly pageBuildId: Schema.brand<Schema.NonEmptyString, "BuildId">;
+  readonly workerBuildId: Schema.brand<Schema.NonEmptyString, "BuildId">;
+}>, import("effect/Cause").YieldableError>;
+/** A page and its worker belong to different Build IDs. Transient, never supported. */
+export declare class VersionSkew extends VersionSkew_base {}
+export declare const matchClientEnvelope: (data: unknown) => Option.Option<ClientEnvelope>;
+export declare const matchWorkerEnvelope: (data: unknown) => Option.Option<WorkerEnvelope>;
+/** None when both sides run one Build ID. */
+export declare const checkVersionSkew: (pageBuildId: BuildId, workerBuildId: BuildId) => Option.Option<VersionSkew>;
+/** Whether an encoded RPC message opens a new call. */
+export declare const isRequest: (message: unknown) => boolean;
+/**
+ * Counts RPC calls in flight on one side of the wire, from the encoded RPC
+ * messages passing through: a Request opens a call, its Exit or Interrupt
+ * closes it, a Defect closes all. `idle` fires on each return to zero.
+ */
+export declare const makeInFlight: (idle?: () => void) => {
+  readonly size: number;
+  /** A message from Worker Client to Worker Server. */
+  request(message: unknown): void;
+  /** A message from Worker Server to Worker Client. */
+  response(message: unknown): void;
+  clear(): void;
+};
+//#endregion
+//# sourceMappingURL=handshake.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handshake.d.ts","names":[],"sources":["../../../../src/pwa/rpc/handshake/handshake.ts"],"mappings":";;;;;;;;;;;;;;;;qBAea;;qBAQA,gBAAc,OAAA,gBAAA,OAAA;;;;;;;;;;;;;;YAaf,wBAAwB,eAAe;;qBAGtC,gBAAc,OAAA,gBAAA,OAAA;;;;;;;;;;;;YAWf,wBAAwB,eAAe;;;;;;qBAGtC,oBAAoB;qBAUpB,sBAAmB,kBAE7B,OAAO,OAAO;qBAGJ,sBAAmB,kBAE7B,OAAO,OAAO;;qBAIJ,mBAAgB,aACd,SAAO,eACL,YACd,OAAO,OAAO;;qBAMJ,YAAS;;;;;;qBAUT,eAAY;WAUjB;;EAIJ,QAAO;;EAMP,SAAQ;EAKR"}

package/dist/pwa/rpc/handshake/handshake.js

@@ -0,0 +1,104 @@
+import { BuildId } from "../../shared/build/build.js";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+//#region src/pwa/rpc/handshake/handshake.ts
+/**
+* Worker RPC's own envelope, distinct from the command key so each
+* listener ignores the other's traffic. Every envelope names its sender's
+* Build ID and the Worker Client connection it belongs to.
+*
+* A connection opens with CONNECT, answered by READY or VERSION_SKEW. A
+* worker that does not know the connection (it was stopped and started
+* again) adopts it when the message is a new Request and the page has no
+* other call open (`open: 0`), since nothing was lost; otherwise it answers
+* UNKNOWN_CONNECTION, and the page opens a new one.
+*/
+const RPC_ENVELOPE_KEY = "__pwaToolkitRpc";
+const Envelope = {
+	[RPC_ENVELOPE_KEY]: Schema.Literal(1),
+	buildId: BuildId,
+	connectionId: Schema.String
+};
+/** Worker Client → Worker Server, via `navigator.serviceWorker.controller.postMessage`. */
+const ClientEnvelope = Schema.Union([Schema.Struct({
+	...Envelope,
+	type: Schema.Literals([
+		"CONNECT",
+		"CLOSE",
+		"PING"
+	])
+}), Schema.Struct({
+	...Envelope,
+	type: Schema.Literal("MESSAGE"),
+	message: Schema.Unknown,
+	/** Calls the page had open on this connection before this message. */
+	open: Schema.Number
+})]);
+/** Worker Server → Worker Client, via the page's `Client.postMessage`. */
+const WorkerEnvelope = Schema.Union([Schema.Struct({
+	...Envelope,
+	type: Schema.Literals([
+		"READY",
+		"VERSION_SKEW",
+		"UNKNOWN_CONNECTION"
+	])
+}), Schema.Struct({
+	...Envelope,
+	type: Schema.Literal("MESSAGE"),
+	message: Schema.Unknown
+})]);
+/** A page and its worker belong to different Build IDs. Transient, never supported. */
+var VersionSkew = class extends Schema.TaggedError()("VersionSkew", {
+	pageBuildId: BuildId,
+	workerBuildId: BuildId
+}) {};
+const decodeClient = Schema.decodeUnknownOption(ClientEnvelope);
+const decodeWorker = Schema.decodeUnknownOption(WorkerEnvelope);
+const hasKey = (data) => typeof data === "object" && data !== null && "__pwaToolkitRpc" in data;
+const matchClientEnvelope = (data) => hasKey(data) ? decodeClient(data) : Option.none();
+const matchWorkerEnvelope = (data) => hasKey(data) ? decodeWorker(data) : Option.none();
+/** None when both sides run one Build ID. */
+const checkVersionSkew = (pageBuildId, workerBuildId) => pageBuildId === workerBuildId ? Option.none() : Option.some(new VersionSkew({
+	pageBuildId,
+	workerBuildId
+}));
+/** Whether an encoded RPC message opens a new call. */
+const isRequest = (message) => typeof message === "object" && message !== null && message._tag === "Request";
+/**
+* Counts RPC calls in flight on one side of the wire, from the encoded RPC
+* messages passing through: a Request opens a call, its Exit or Interrupt
+* closes it, a Defect closes all. `idle` fires on each return to zero.
+*/
+const makeInFlight = (idle = () => {}) => {
+	const open = /* @__PURE__ */ new Set();
+	const close = (id) => {
+		if (open.delete(id) && open.size === 0) idle();
+	};
+	const tagged = (message) => typeof message === "object" && message !== null ? message : void 0;
+	return {
+		get size() {
+			return open.size;
+		},
+		/** A message from Worker Client to Worker Server. */
+		request(message) {
+			const m = tagged(message);
+			if (m?._tag === "Request") open.add(String(m.id));
+			else if (m?._tag === "Interrupt") close(String(m.requestId));
+		},
+		/** A message from Worker Server to Worker Client. */
+		response(message) {
+			const m = tagged(message);
+			if (m?._tag === "Exit") close(String(m.requestId));
+			else if (m?._tag === "Defect") this.clear();
+		},
+		clear() {
+			if (open.size === 0) return;
+			open.clear();
+			idle();
+		}
+	};
+};
+//#endregion
+export { ClientEnvelope, RPC_ENVELOPE_KEY, VersionSkew, WorkerEnvelope, checkVersionSkew, isRequest, makeInFlight, matchClientEnvelope, matchWorkerEnvelope };
+
+//# sourceMappingURL=handshake.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handshake.js","names":[],"sources":["../../../../src/pwa/rpc/handshake/handshake.ts"],"sourcesContent":["import * as Option from 'effect/Option';\nimport * as Schema from 'effect/Schema';\nimport { BuildId } from '../../shared/build/index.js';\n\n/**\n * Worker RPC's own envelope, distinct from the command key so each\n * listener ignores the other's traffic. Every envelope names its sender's\n * Build ID and the Worker Client connection it belongs to.\n *\n * A connection opens with CONNECT, answered by READY or VERSION_SKEW. A\n * worker that does not know the connection (it was stopped and started\n * again) adopts it when the message is a new Request and the page has no\n * other call open (`open: 0`), since nothing was lost; otherwise it answers\n * UNKNOWN_CONNECTION, and the page opens a new one.\n */\nexport const RPC_ENVELOPE_KEY = '__pwaToolkitRpc';\nconst Envelope = {\n  [RPC_ENVELOPE_KEY]: Schema.Literal(1),\n  buildId: BuildId,\n  connectionId: Schema.String,\n} as const;\n\n/** Worker Client → Worker Server, via `navigator.serviceWorker.controller.postMessage`. */\nexport const ClientEnvelope = Schema.Union([\n  Schema.Struct({\n    ...Envelope,\n    type: Schema.Literals(['CONNECT', 'CLOSE', 'PING']),\n  }),\n  Schema.Struct({\n    ...Envelope,\n    type: Schema.Literal('MESSAGE'),\n    message: Schema.Unknown,\n    /** Calls the page had open on this connection before this message. */\n    open: Schema.Number,\n  }),\n]);\nexport type ClientEnvelope = typeof ClientEnvelope.Type;\n\n/** Worker Server → Worker Client, via the page's `Client.postMessage`. */\nexport const WorkerEnvelope = Schema.Union([\n  Schema.Struct({\n    ...Envelope,\n    type: Schema.Literals(['READY', 'VERSION_SKEW', 'UNKNOWN_CONNECTION']),\n  }),\n  Schema.Struct({\n    ...Envelope,\n    type: Schema.Literal('MESSAGE'),\n    message: Schema.Unknown,\n  }),\n]);\nexport type WorkerEnvelope = typeof WorkerEnvelope.Type;\n\n/** A page and its worker belong to different Build IDs. Transient, never supported. */\nexport class VersionSkew extends Schema.TaggedError<VersionSkew>()(\n  'VersionSkew',\n  { pageBuildId: BuildId, workerBuildId: BuildId },\n) {}\n\nconst decodeClient = Schema.decodeUnknownOption(ClientEnvelope);\nconst decodeWorker = Schema.decodeUnknownOption(WorkerEnvelope);\nconst hasKey = (data: unknown): boolean =>\n  typeof data === 'object' && data !== null && RPC_ENVELOPE_KEY in data;\n\nexport const matchClientEnvelope = (\n  data: unknown,\n): Option.Option<ClientEnvelope> =>\n  hasKey(data) ? decodeClient(data) : Option.none();\n\nexport const matchWorkerEnvelope = (\n  data: unknown,\n): Option.Option<WorkerEnvelope> =>\n  hasKey(data) ? decodeWorker(data) : Option.none();\n\n/** None when both sides run one Build ID. */\nexport const checkVersionSkew = (\n  pageBuildId: BuildId,\n  workerBuildId: BuildId,\n): Option.Option<VersionSkew> =>\n  pageBuildId === workerBuildId\n    ? Option.none()\n    : Option.some(new VersionSkew({ pageBuildId, workerBuildId }));\n\n/** Whether an encoded RPC message opens a new call. */\nexport const isRequest = (message: unknown): boolean =>\n  typeof message === 'object' &&\n  message !== null &&\n  (message as { _tag?: unknown })._tag === 'Request';\n\n/**\n * Counts RPC calls in flight on one side of the wire, from the encoded RPC\n * messages passing through: a Request opens a call, its Exit or Interrupt\n * closes it, a Defect closes all. `idle` fires on each return to zero.\n */\nexport const makeInFlight = (idle: () => void = () => {}) => {\n  const open = new Set<unknown>();\n  const close = (id: unknown) => {\n    if (open.delete(id) && open.size === 0) idle();\n  };\n  const tagged = (message: unknown): Record<string, unknown> | undefined =>\n    typeof message === 'object' && message !== null\n      ? (message as Record<string, unknown>)\n      : undefined;\n  return {\n    get size() {\n      return open.size;\n    },\n    /** A message from Worker Client to Worker Server. */\n    request(message: unknown): void {\n      const m = tagged(message);\n      if (m?._tag === 'Request') open.add(String(m.id));\n      else if (m?._tag === 'Interrupt') close(String(m.requestId));\n    },\n    /** A message from Worker Server to Worker Client. */\n    response(message: unknown): void {\n      const m = tagged(message);\n      if (m?._tag === 'Exit') close(String(m.requestId));\n      else if (m?._tag === 'Defect') this.clear();\n    },\n    clear(): void {\n      if (open.size === 0) return;\n      open.clear();\n      idle();\n    },\n  };\n};\n"],"mappings":";;;;;;;;;;;;;;;AAeA,MAAa,mBAAmB;AAChC,MAAM,WAAW;EACd,mBAAmB,OAAO,QAAQ,CAAC;CACpC,SAAS;CACT,cAAc,OAAO;AACvB;;AAGA,MAAa,iBAAiB,OAAO,MAAM,CACzC,OAAO,OAAO;CACZ,GAAG;CACH,MAAM,OAAO,SAAS;EAAC;EAAW;EAAS;CAAM,CAAC;AACpD,CAAC,GACD,OAAO,OAAO;CACZ,GAAG;CACH,MAAM,OAAO,QAAQ,SAAS;CAC9B,SAAS,OAAO;;CAEhB,MAAM,OAAO;AACf,CAAC,CACH,CAAC;;AAID,MAAa,iBAAiB,OAAO,MAAM,CACzC,OAAO,OAAO;CACZ,GAAG;CACH,MAAM,OAAO,SAAS;EAAC;EAAS;EAAgB;CAAoB,CAAC;AACvE,CAAC,GACD,OAAO,OAAO;CACZ,GAAG;CACH,MAAM,OAAO,QAAQ,SAAS;CAC9B,SAAS,OAAO;AAClB,CAAC,CACH,CAAC;;AAID,IAAa,cAAb,cAAiC,OAAO,YAAyB,CAAC,CAChE,eACA;CAAE,aAAa;CAAS,eAAe;AAAQ,CACjD,CAAC,CAAC,CAAC;AAEH,MAAM,eAAe,OAAO,oBAAoB,cAAc;AAC9D,MAAM,eAAe,OAAO,oBAAoB,cAAc;AAC9D,MAAM,UAAU,SACd,OAAO,SAAS,YAAY,SAAS,QAAA,qBAA4B;AAEnE,MAAa,uBACX,SAEA,OAAO,IAAI,IAAI,aAAa,IAAI,IAAI,OAAO,KAAK;AAElD,MAAa,uBACX,SAEA,OAAO,IAAI,IAAI,aAAa,IAAI,IAAI,OAAO,KAAK;;AAGlD,MAAa,oBACX,aACA,kBAEA,gBAAgB,gBACZ,OAAO,KAAK,IACZ,OAAO,KAAK,IAAI,YAAY;CAAE;CAAa;AAAc,CAAC,CAAC;;AAGjE,MAAa,aAAa,YACxB,OAAO,YAAY,YACnB,YAAY,QACX,QAA+B,SAAS;;;;;;AAO3C,MAAa,gBAAgB,aAAyB,CAAC,MAAM;CAC3D,MAAM,uBAAO,IAAI,IAAa;CAC9B,MAAM,SAAS,OAAgB;EAC7B,IAAI,KAAK,OAAO,EAAE,KAAK,KAAK,SAAS,GAAG,KAAK;CAC/C;CACA,MAAM,UAAU,YACd,OAAO,YAAY,YAAY,YAAY,OACtC,UACD,KAAA;CACN,OAAO;EACL,IAAI,OAAO;GACT,OAAO,KAAK;EACd;;EAEA,QAAQ,SAAwB;GAC9B,MAAM,IAAI,OAAO,OAAO;GACxB,IAAI,GAAG,SAAS,WAAW,KAAK,IAAI,OAAO,EAAE,EAAE,CAAC;QAC3C,IAAI,GAAG,SAAS,aAAa,MAAM,OAAO,EAAE,SAAS,CAAC;EAC7D;;EAEA,SAAS,SAAwB;GAC/B,MAAM,IAAI,OAAO,OAAO;GACxB,IAAI,GAAG,SAAS,QAAQ,MAAM,OAAO,EAAE,SAAS,CAAC;QAC5C,IAAI,GAAG,SAAS,UAAU,KAAK,MAAM;EAC5C;EACA,QAAc;GACZ,IAAI,KAAK,SAAS,GAAG;GACrB,KAAK,MAAM;GACX,KAAK;EACP;CACF;AACF"}

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

@@ -0,0 +1,2 @@
+import { ClientEnvelope, RPC_ENVELOPE_KEY, VersionSkew, WorkerEnvelope, checkVersionSkew, isRequest, makeInFlight, matchClientEnvelope, matchWorkerEnvelope } from "./handshake.js";
+export { ClientEnvelope, RPC_ENVELOPE_KEY, VersionSkew, WorkerEnvelope, checkVersionSkew, isRequest, makeInFlight, matchClientEnvelope, matchWorkerEnvelope };

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

@@ -0,0 +1,2 @@
+import { ClientEnvelope, RPC_ENVELOPE_KEY, VersionSkew, WorkerEnvelope, checkVersionSkew, isRequest, makeInFlight, matchClientEnvelope, matchWorkerEnvelope } from "./handshake.js";
+export { ClientEnvelope, RPC_ENVELOPE_KEY, VersionSkew, WorkerEnvelope, checkVersionSkew, isRequest, makeInFlight, matchClientEnvelope, matchWorkerEnvelope };

package/dist/pwa/rpc/worker/connections.d.ts

@@ -0,0 +1,31 @@
+import { makeInFlight } from "../handshake/handshake.js";
+import "../handshake/index.js";
+//#region src/pwa/rpc/worker/connections.d.ts
+/** The part of a Service Worker API `Client` the Worker Server talks to. */
+export interface PageHandle {
+  readonly id: string;
+  postMessage(message: unknown, transfer: Transferable[]): void;
+}
+export interface Connection {
+  readonly portId: number;
+  readonly clientId: string;
+  readonly connectionId: string;
+  page: PageHandle;
+  readonly inFlight: ReturnType<typeof makeInFlight>;
+}
+/**
+ * The Worker Client connections this worker instance has seen. Each gets the
+ * numeric port id Effect's runner protocol uses. Held in memory only, so a
+ * restarted worker starts empty.
+ */
+export declare const makeConnections: (onIdle: () => void) => {
+  open(page: PageHandle, connectionId: string): Connection;
+  find: (clientId: string, connectionId: string) => Connection | undefined;
+  byPort: (portId: number) => Connection | undefined;
+  all: () => Connection[];
+  ofClient: (clientId: string) => Connection[];
+  close(connection: Connection): void;
+  readonly busy: boolean;
+};
+//#endregion
+//# sourceMappingURL=connections.d.ts.map

package/dist/pwa/rpc/worker/connections.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connections.d.ts","names":[],"sources":["../../../../src/pwa/rpc/worker/connections.ts"],"mappings":";;;;iBAGiB;WACN;EACT,YAAY,kBAAkB,UAAU;;iBAGzB;WACN;WACA;WACA;EACT,MAAM;WACG,UAAU,kBAAkB;;;;;;;qBAQ1B,kBAAe;EAQxB,KAAI,MAAO,YAAU,uBAAyB;EAiB9C,OAAI,kBAAmB,yBAAsB;EAE7C,SAAM,mBAAiB;EACvB,WAAG;EACH,WAAQ,qBAAmB;EAE3B,MAAK,YAAa;WAKd"}