@thomasfosterau/legation-browser 0.0.0 → 0.1.0

package/dist/index.js

@@ -0,0 +1,1109 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
+import { IndexedDb } from "@effect/platform-browser";
+import { Client, ClientStore, Identity, StoreError, TransportError } from "@thomasfosterau/legation";
+import * as Layer from "effect/Layer";
+import { AtomicKeyValue, ClientEngine, ClientView, EngineHost, EngineHost as EngineHost$1, HttpCache, Mirror, Mirror as Mirror$1, MirrorChannel, MirrorProtocol, MirrorProtocol as MirrorProtocol$1, PushPoke, Subscriptions, Subset, Telemetry } from "@thomasfosterau/legation/internal";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as P from "effect/Predicate";
+import * as Result from "effect/Result";
+import { KeyValueStore } from "effect/persistence";
+import * as Queue from "effect/Queue";
+import * as Exit from "effect/Exit";
+import * as Ref from "effect/Ref";
+import * as Scope from "effect/Scope";
+import * as Stream from "effect/Stream";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+import * as Clock from "effect/Clock";
+import * as Duration from "effect/Duration";
+import * as Option from "effect/Option";
+import * as Metric from "effect/Metric";
+import * as Schedule from "effect/Schedule";
+import * as Schema from "effect/Schema";
+// src/internal/IndexedDbKeyValue.ts
+/**
+* The platform-compatible IndexedDB key-value seam under {@link IndexedDbClientStore} (#393). Not part of
+* the package's public surface: the store and the tests import it from here, and nothing re-exports it.
+*
+* It opens the platform's database without a version, keeps one connection per layer, and gives the
+* store a `KeyValueStore` whose records the platform's `BrowserKeyValueStore` reads back, plus the
+* `AtomicKeyValue` batch over the same entries store.
+*/
+/**
+* The database and object store this module reads and writes: the database
+* platform-browser's `BrowserKeyValueStore.layerIndexedDb` (4.0.2) also uses,
+* by default `effect_key_value_store`, with an `entries` store keyed by `key`
+* whose records are `{ key, value }`. Both are written here in the same layout,
+* so the store and the atomic batch read one database.
+*
+* The database is opened without a version (#393). The platform's layer opens
+* at version 1, which fails with a `VersionError` on a database a later version
+* created, and that failure kills the layer. Opening at whatever version exists
+* keeps the layer alive. A database without the `entries` store cannot be fixed
+* from here (creating it needs a version upgrade), so its reads and its batch
+* fail with an error that names it.
+*/
+const PLATFORM_DATABASE = "effect_key_value_store";
+const ENTRIES_STORE = "entries";
+/**
+* What every call on a store whose database another connection upgraded fails with (#393). The
+* connection is closed by then, so the call cannot run; the message says why.
+*/
+const UPGRADED_MESSAGE = "the IndexedDB database was upgraded by another connection; reload to continue";
+/**
+* Open the platform's database at the version it has, creating the entries
+* store only when the database is new. The connection closes itself when
+* another connection asks for a newer version, rather than blocking that
+* connection's upgrade (`onversionchange`); after that, its calls fail with
+* {@link UPGRADED_MESSAGE}.
+*/
+const openDatabase = (database) => Effect.gen(function* () {
+	const idb = (yield* IndexedDb.IndexedDb).indexedDB;
+	return yield* Effect.callback((resume) => {
+		const fail = (cause) => resume(Effect.fail(new StoreError({
+			message: "Failed to open the IndexedDB store",
+			cause
+		})));
+		const opened = Result.try(() => idb.open(database));
+		if (Result.isFailure(opened)) {
+			fail(opened.failure);
+			return;
+		}
+		const request = opened.success;
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains(ENTRIES_STORE)) db.createObjectStore(ENTRIES_STORE, { keyPath: "key" });
+		};
+		request.onsuccess = () => {
+			const connection = {
+				db: request.result,
+				upgraded: false
+			};
+			connection.db.onversionchange = () => {
+				connection.upgraded = true;
+				connection.db.close();
+			};
+			resume(Effect.succeed(connection));
+		};
+		request.onerror = () => fail(request.error);
+	});
+});
+/**
+* Abort `transaction`, ignoring the `InvalidStateError` an already-finished
+* transaction throws: there is nothing left to abort then.
+*/
+const abortQuietly = (transaction) => {
+	Result.try(() => transaction.abort());
+};
+/** A clear error for a database that lacks the entries store (see the module note above). */
+const missingEntriesStore = (db, method, key) => new KeyValueStore.KeyValueStoreError({
+	method,
+	message: `IndexedDB database "${db.name}" has no "${ENTRIES_STORE}" object store`,
+	...key === void 0 ? {} : { key }
+});
+/**
+* One request in its own transaction, resolved when the transaction completes,
+* so a write is durable before the caller continues. A failed or aborted
+* transaction fails the call.
+*/
+const runRequest = (connection, mode, failure, evaluate) => Effect.callback((resume) => {
+	let settled = false;
+	let result;
+	const finish = (effect) => {
+		if (settled) return;
+		settled = true;
+		resume(effect);
+	};
+	const fail = (cause) => finish(Effect.fail(new KeyValueStore.KeyValueStoreError({
+		...failure,
+		message: connection.upgraded ? UPGRADED_MESSAGE : failure.message,
+		cause
+	})));
+	if (connection.upgraded) {
+		finish(Effect.fail(new KeyValueStore.KeyValueStoreError({
+			method: failure.method,
+			message: UPGRADED_MESSAGE,
+			...failure.key === void 0 ? {} : { key: failure.key }
+		})));
+		return;
+	}
+	const db = connection.db;
+	if (!db.objectStoreNames.contains(ENTRIES_STORE)) {
+		finish(Effect.fail(missingEntriesStore(db, failure.method, failure.key)));
+		return;
+	}
+	const began = Result.try(() => db.transaction(ENTRIES_STORE, mode));
+	if (Result.isFailure(began)) {
+		fail(began.failure);
+		return;
+	}
+	const transaction = began.success;
+	transaction.oncomplete = () => finish(Effect.succeed(result));
+	transaction.onerror = () => fail(transaction.error);
+	transaction.onabort = () => fail(transaction.error);
+	const issued = Result.try(() => {
+		const request = evaluate(transaction.objectStore(ENTRIES_STORE));
+		request.onsuccess = () => {
+			result = request.result;
+		};
+		request.onerror = () => fail(request.error);
+	});
+	if (Result.isFailure(issued)) {
+		fail(issued.failure);
+		abortQuietly(transaction);
+	}
+	return Effect.sync(() => {
+		if (settled) return;
+		settled = true;
+		abortQuietly(transaction);
+	});
+});
+/**
+* The platform's `KeyValueStore` semantics over the database {@link openDatabase}
+* opened: a string value reads back as a string, a `Uint8Array` as bytes, and
+* every call is its own transaction, as the platform's store makes them.
+*/
+const keyValueOver = (connection) => {
+	return KeyValueStore.make({
+		get: (key) => runRequest(connection, "readonly", {
+			method: "get",
+			message: "Failed to get value from backing store",
+			key
+		}, (store) => store.get(key)).pipe(Effect.map((found) => P.isString(found?.value) ? found.value : void 0)),
+		getUint8Array: (key) => runRequest(connection, "readonly", {
+			method: "getUint8Array",
+			message: "Failed to get value from backing store",
+			key
+		}, (store) => store.get(key)).pipe(Effect.map((found) => found?.value instanceof Uint8Array ? found.value : void 0)),
+		has: (key) => runRequest(connection, "readonly", {
+			method: "has",
+			message: "Failed to check key in backing store",
+			key
+		}, (store) => store.count(key)).pipe(Effect.map((count) => count > 0)),
+		set: (key, value) => runRequest(connection, "readwrite", {
+			method: "set",
+			message: "Failed to set value in backing store",
+			key
+		}, (store) => store.put({
+			key,
+			value
+		})).pipe(Effect.asVoid),
+		remove: (key) => runRequest(connection, "readwrite", {
+			method: "remove",
+			message: "Failed to remove value from backing store",
+			key
+		}, (store) => store.delete(key)).pipe(Effect.asVoid),
+		clear: runRequest(connection, "readwrite", {
+			method: "clear",
+			message: "Failed to clear backing store"
+		}, (store) => store.clear()).pipe(Effect.asVoid),
+		size: runRequest(connection, "readonly", {
+			method: "size",
+			message: "Failed to get backing store size"
+		}, (store) => store.count()),
+		keys: runRequest(connection, "readonly", {
+			method: "keys",
+			message: "Failed to list keys in backing store"
+		}, (store) => store.getAllKeys()).pipe(Effect.map((keys) => keys.filter(P.isString)))
+	});
+};
+/**
+* Commit `ops` in one `readwrite` transaction on the entries store: IndexedDB
+* commits a transaction whole or not at all, so a failed or interrupted batch
+* leaves the store as it was.
+*/
+const commitOps = (connection, ops) => Effect.callback((resume) => {
+	let settled = false;
+	const finish = (effect) => {
+		if (settled) return;
+		settled = true;
+		resume(effect);
+	};
+	const fail = (cause) => finish(Effect.fail(new StoreError({
+		message: connection.upgraded ? UPGRADED_MESSAGE : "Failed to commit an atomic batch to IndexedDB",
+		cause
+	})));
+	if (connection.upgraded) {
+		finish(Effect.fail(new StoreError({ message: UPGRADED_MESSAGE })));
+		return;
+	}
+	const db = connection.db;
+	if (!db.objectStoreNames.contains(ENTRIES_STORE)) {
+		finish(Effect.fail(new StoreError({ message: `Cannot commit an atomic batch: IndexedDB database "${db.name}" has no "${ENTRIES_STORE}" object store` })));
+		return;
+	}
+	const began = Result.try(() => db.transaction(ENTRIES_STORE, "readwrite"));
+	if (Result.isFailure(began)) {
+		fail(began.failure);
+		return;
+	}
+	const transaction = began.success;
+	const abort = () => abortQuietly(transaction);
+	transaction.oncomplete = () => finish(Effect.void);
+	transaction.onerror = () => fail(transaction.error);
+	transaction.onabort = () => fail(transaction.error);
+	const issued = Result.try(() => {
+		const entries = transaction.objectStore(ENTRIES_STORE);
+		Arr.forEach(ops, (op) => {
+			if (op._tag === "Set") entries.put({
+				key: op.key,
+				value: op.value
+			});
+			else entries.delete(op.key);
+		});
+	});
+	if (Result.isFailure(issued)) {
+		fail(issued.failure);
+		abort();
+	}
+	return Effect.sync(() => {
+		if (!settled) {
+			settled = true;
+			abort();
+		}
+	});
+});
+/**
+* The platform `KeyValueStore` over IndexedDB, opened without a version (see
+* the module note above). Keys are the full keys the store holds.
+*/
+const keyValueLayer = (database) => Layer.effect(KeyValueStore.KeyValueStore)(Effect.gen(function* () {
+	const connection = yield* Effect.acquireRelease(openDatabase(database ?? PLATFORM_DATABASE), (opened) => Effect.sync(() => opened.db.close())).pipe(Effect.orDie);
+	return keyValueOver(connection);
+}));
+/**
+* Every string entry in the entries store, read in one `readonly` transaction (#392): a single
+* request, so the records are one state of the database and a batch another connection commits is
+* either wholly in them or wholly absent. The platform store writes only strings for the keys this
+* layer reads, so other values are left out.
+*/
+const readEntries = (connection) => runRequest(connection, "readonly", {
+	method: "getAll",
+	message: "Failed to read the IndexedDB store"
+}, (store) => store.getAll()).pipe(Effect.map((records) => records.flatMap((record) => P.isString(record.value) ? [{
+	key: record.key,
+	value: record.value
+}] : [])), Effect.mapError((error) => new StoreError({
+	message: error.message,
+	cause: error
+})));
+/**
+* The atomic batch over the same IndexedDB database as the `KeyValueStore`
+* (#393), with its one-transaction read of the entries (#392). Keys arrive in
+* full, namespace prefix included, as the store holds them, so the batch needs
+* no knowledge of the prefix.
+*/
+const atomicKeyValueLayer = (database) => Layer.effect(AtomicKeyValue.AtomicKeyValue)(Effect.gen(function* () {
+	const connection = yield* Effect.acquireRelease(openDatabase(database ?? PLATFORM_DATABASE), (opened) => Effect.sync(() => opened.db.close())).pipe(Effect.orDie);
+	return AtomicKeyValue.AtomicKeyValue.of({
+		apply: (ops) => Arr.isReadonlyArrayEmpty(ops) ? Effect.void : commitOps(connection, ops),
+		readAll: readEntries(connection)
+	});
+}));
+// src/IndexedDbClientStore.ts
+/**
+* IndexedDbClientStore
+*
+* The durable browser ClientStore (ADR-0010): core's KeyValueStore-backed
+* store over platform-browser's IndexedDB KeyValueStore. Every engine
+* state transition lands in IndexedDB, so a killed service worker (or
+* closed tab in main-thread hosting) rehydrates losslessly.
+*
+* A durable replica on a browser is a durable replica on a **device**, which
+* is where the identity boundary earns its keep (#212, CONTEXT.md): a
+* multi-tenant app on a shared device syncs one user's private rows
+* legitimately — the server's auth filter said they could have them — and
+* then the next user opens the app to the freshest thing on the machine.
+* There are two ways to hold that line, and both are here:
+*
+* - {@link layerWindow} with an `identity`: **one replica, reset on change.**
+*   The store stamps the fingerprint and compares it on open; a mismatch
+*   quarantines the unpushed journal under the superseded fingerprint and
+*   drops rows and cookie before anything can read them.
+* - {@link layerNamespaced}: **one replica per identity.** The fingerprint
+*   derives the key prefix, so two principals never share a keyspace and
+*   nothing needs resetting.
+*
+* A version change from another connection (a newer app build upgrading the
+* database, or a deletion) closes this store's connections, since they would
+* otherwise block it. From then on every call fails with an error that says
+* the database was upgraded by another connection and asks for a reload. The
+* store never reopens itself, so a reload is the way back.
+*
+* Which to choose: namespace when the device has a small number of regular
+* users who switch back and forth (each keeps a warm replica, so switching
+* back costs no re-pull, at the price of holding both on disk); reset when
+* sign-ins are one-off or unbounded — a kiosk, a shared library machine —
+* where accumulating a replica per visitor is the worse trade.
+*/
+var IndexedDbClientStore_exports = /* @__PURE__ */ __exportAll({
+	layer: () => layer,
+	layerNamespaced: () => layerNamespaced,
+	layerWindow: () => layerWindow,
+	namespacedPrefix: () => namespacedPrefix
+});
+/** The store options that reach core, absent keys left absent. */
+const keyValueOptions = (options) => ({
+	...options?.prefix === void 0 ? {} : { prefix: options.prefix },
+	...options?.identity === void 0 ? {} : { identity: options.identity }
+});
+/**
+* ClientStore over IndexedDB. Requires the `IndexedDb` primitives service;
+* use {@link layerWindow} where browser globals are available, or provide
+* `IndexedDb` yourself (tests use fake-indexeddb).
+*
+* A pull and a push acknowledgement commit as one IndexedDB transaction (#393),
+* so a durable pull writes its rows once and writes no release record.
+*/
+const layer = (options) => ClientStore.layerKeyValue(keyValueOptions(options)).pipe(Layer.provide(Layer.merge(keyValueLayer(options?.database), atomicKeyValueLayer(options?.database))));
+/** Self-contained layer using the browser's global `indexedDB`. */
+const layerWindow = (options) => layer(options).pipe(Layer.provide(IndexedDb.layerWindow));
+/**
+* The key prefix {@link layerNamespaced} derives for a fingerprint:
+* core's `"legation/"` namespace with a percent-encoded identity segment
+* under it, so two principals' replicas cannot collide and neither can
+* collide with an un-namespaced one.
+*/
+const namespacedPrefix = (identity) => `legation/identity/${Identity.keySegment(identity)}/`;
+/**
+* The namespacing alternative to resetting (#212): one replica per identity
+* in a single IndexedDB database, keyed by fingerprint.
+*
+* A principal's rows are unreachable from another principal's store because
+* they are under a different key prefix — no comparison, no reset, and a
+* user who switches back finds their replica still warm. The fingerprint is
+* still stamped, so a store reached through this layer keeps the same
+* guarantee if it is ever opened un-namespaced.
+*
+* The cost is disk: every identity that has ever signed in on this device
+* keeps a replica until something clears it. Prefer {@link layerWindow} with
+* an `identity` where sign-ins are unbounded.
+*
+* Pass `database` to isolate at the database level instead of the key level
+* — a heavier boundary (a whole IndexedDB database per identity, deletable
+* in one call) for apps that want it.
+*/
+const layerNamespaced = (identity, options) => layerWindow({
+	...options?.database === void 0 ? {} : { database: options.database },
+	prefix: namespacedPrefix(identity),
+	identity
+});
+// src/BroadcastMirrorChannel.ts
+/**
+* BroadcastMirrorChannel
+*
+* The browser binding of the `MirrorChannel` seam: schema-defined mirror
+* protocol messages over a `BroadcastChannel` name. Pair one in the engine
+* host with one per client context (tab, window, worker) — BroadcastChannel
+* semantics mean a side never receives its own posts.
+*/
+var BroadcastMirrorChannel_exports = /* @__PURE__ */ __exportAll({ make: () => make$1 });
+/** A {@link MirrorChannel.MirrorChannel} over a `BroadcastChannel` name. */
+const make$1 = (name) => Effect.gen(function* () {
+	const channel = yield* Effect.acquireRelease(Effect.sync(() => new BroadcastChannel(name)), (ch) => Effect.sync(() => ch.close()));
+	return {
+		post: (message) => Effect.try({
+			try: () => channel.postMessage(message),
+			catch: (cause) => new TransportError({
+				message: `BroadcastChannel post failed`,
+				cause
+			})
+		}),
+		subscribe: Effect.gen(function* () {
+			const queue = yield* Queue.unbounded();
+			yield* Effect.acquireRelease(Effect.sync(() => {
+				const listener = (event) => {
+					Queue.offerUnsafe(queue, event.data);
+				};
+				channel.addEventListener("message", listener);
+				return listener;
+			}), (listener) => Effect.sync(() => channel.removeEventListener("message", listener)));
+			return { take: Queue.take(queue).pipe(Effect.orDie) };
+		})
+	};
+});
+// src/ServiceWorkerHost.ts
+var ServiceWorkerHost_exports = /* @__PURE__ */ __exportAll({
+	defaultChannelName: () => defaultChannelName,
+	run: () => run$1,
+	start: () => start
+});
+/** The default channel name; Mirror setups should use the same one. */
+const defaultChannelName = "legation";
+/**
+* Start the host: serve mirrors over the broadcast channel and start the
+* engine's sync loop (pull on poke, push+pull on reconnect), then return
+* the {@link Host}. Both the host and `runSync` fork their fibers into the
+* surrounding scope, so the caller must keep that scope open for as long
+* as it serves (`Effect.never`, as {@link run} does); closing it stops
+* serving.
+*/
+const start = (options = {}) => Effect.gen(function* () {
+	const { channelName = defaultChannelName, registry, nodes, urls, backgroundSync, pushPoke } = options;
+	const engine = yield* ClientEngine.ClientEngine;
+	const channel = yield* make$1(channelName);
+	const host = yield* EngineHost$1.run({
+		channel,
+		engine,
+		...registry === void 0 ? {} : { registry },
+		...nodes === void 0 ? {} : { nodes },
+		...urls === void 0 ? {} : { urls }
+	});
+	yield* engine.runSync.pipe(Effect.ignore);
+	if (backgroundSync !== void 0) yield* backgroundSync.serve(engine);
+	if (pushPoke !== void 0) yield* pushPoke.serve(engine);
+	return {
+		engine,
+		registrations: host.registrations
+	};
+});
+/**
+* Run the host: {@link start}, then serve forever. NEVER returns — both the
+* host and `runSync` fork their fibers into the surrounding scope, so
+* returning would let a caller's `Effect.scoped` tear the whole host down
+* immediately. Interrupt it / close the scope to stop serving.
+*/
+const run$1 = (options = {}) => start(options).pipe(Effect.andThen(Effect.never));
+// src/ElectedHost.ts
+var ElectedHost_exports = /* @__PURE__ */ __exportAll({ run: () => run });
+/** Resolve the ambient `navigator.locks`, `undefined` where it (or `navigator`) doesn't exist. */
+const globalLocks = () => globalThis.navigator?.locks;
+/**
+* Wait to be granted `name` (Web Lock, exclusive mode), then hold it until
+* this effect's scope closes. While waiting, interruption aborts the
+* pending request (`LockManager.request`'s own `signal` option) instead of
+* leaving it queued forever.
+*/
+const electLeader = (locks, name) => Effect.acquireRelease(Effect.callback((resume, signal) => {
+	locks.request(name, {
+		mode: "exclusive",
+		signal
+	}, () => new Promise((resolveHeld) => {
+		resume(Effect.succeed(() => resolveHeld()));
+	})).catch(() => void 0);
+}), (release) => Effect.sync(release), { interruptible: true }).pipe(Effect.asVoid);
+/**
+* A `ClientView` over a `SubscriptionRef` of the currently-active view:
+* one-shot calls (`query`/`mutate`/…) always hit whatever is current;
+* `observe`/`observeNamed`/`related` re-subscribe themselves against the
+* new view the moment it changes (`Stream.switchMap`, tearing the old
+* subscription down first — a mirror's own `unsubscribe`/interrupt path);
+* explicit pins (`subscribe`/`subscribeQuery`) have no ongoing stream to
+* redo that for them, so this keeps its own ledger and replays it onto
+* every newly-active view.
+*/
+const switchingView = (viewRef) => Effect.gen(function* () {
+	const pinnedSubsets = yield* Ref.make(/* @__PURE__ */ new Map());
+	const pinnedNamed = yield* Ref.make(/* @__PURE__ */ new Map());
+	yield* Effect.forkScoped(Stream.runForEach(Stream.drop(SubscriptionRef.changes(viewRef), 1), (view) => Effect.gen(function* () {
+		const subsets = yield* Ref.get(pinnedSubsets);
+		const named = yield* Ref.get(pinnedNamed);
+		yield* Effect.forEach(subsets.values(), (subset) => view.subscribe(subset).pipe(Effect.ignore), { discard: true });
+		yield* Effect.forEach(named.values(), (entry) => view.subscribeQuery(entry.name, entry.args).pipe(Effect.ignore), { discard: true });
+	})).pipe(Effect.ignore));
+	const current = SubscriptionRef.get(viewRef);
+	const withCurrent = (f) => Effect.flatMap(current, f);
+	return {
+		query: (subset) => withCurrent((view) => view.query(subset)),
+		observe: (subset) => SubscriptionRef.changes(viewRef).pipe(Stream.switchMap((view) => view.observe(subset))),
+		observeChanges: (subset, changeOptions) => SubscriptionRef.changes(viewRef).pipe(Stream.switchMap((view) => view.observeChanges(subset, changeOptions))),
+		subscribe: (subset) => Ref.update(pinnedSubsets, (map) => new Map(map).set(Subset.hash(subset), subset)).pipe(Effect.andThen(withCurrent((view) => view.subscribe(subset)))),
+		unsubscribe: (subset) => Ref.update(pinnedSubsets, (map) => {
+			const next = new Map(map);
+			next.delete(Subset.hash(subset));
+			return next;
+		}).pipe(Effect.andThen(withCurrent((view) => view.unsubscribe(subset)))),
+		subscribeQuery: (name, args) => Ref.update(pinnedNamed, (map) => new Map(map).set(MirrorProtocol$1.namedKey(name, args), {
+			name,
+			args
+		})).pipe(Effect.andThen(withCurrent((view) => view.subscribeQuery(name, args)))),
+		unsubscribeQuery: (name, args) => Ref.update(pinnedNamed, (map) => {
+			const next = new Map(map);
+			next.delete(MirrorProtocol$1.namedKey(name, args));
+			return next;
+		}).pipe(Effect.andThen(withCurrent((view) => view.unsubscribeQuery(name, args)))),
+		queryNamed: (name, args) => withCurrent((view) => view.queryNamed(name, args)),
+		pulled: (key) => withCurrent((view) => view.pulled(key)),
+		observeNamed: (name, args) => SubscriptionRef.changes(viewRef).pipe(Stream.switchMap((view) => view.observeNamed(name, args))),
+		related: (registry, collectionName, subset, edges) => Effect.succeed(SubscriptionRef.changes(viewRef).pipe(Stream.switchMap((view) => Stream.unwrap(view.related(registry, collectionName, subset, edges))))),
+		pinEdges: (registry, collectionName, subset, edges) => Effect.gen(function* () {
+			const scope = yield* Effect.scope;
+			const held = yield* Ref.make(void 0);
+			yield* Effect.forkIn(Stream.runForEach(SubscriptionRef.changes(viewRef), (view) => Effect.gen(function* () {
+				const previous = yield* Ref.getAndSet(held, void 0);
+				if (previous !== void 0) yield* Scope.close(previous, Exit.void);
+				const child = yield* Scope.fork(scope);
+				yield* view.pinEdges(registry, collectionName, subset, edges).pipe(Scope.provide(child));
+				yield* Ref.set(held, child);
+			})).pipe(Effect.ignore), scope);
+		}),
+		read: (subsets) => withCurrent((view) => view.read === void 0 ? Effect.fail(new TransportError({ message: "ElectedHost: no fallthrough read available on this tier" })) : view.read(subsets)),
+		mutate: (mutator, args) => withCurrent((view) => view.mutate(mutator, args)),
+		mutateWithAck: (mutator, args) => withCurrent((view) => view.mutateWithAck(mutator, args)),
+		mutationStates: SubscriptionRef.changes(viewRef).pipe(Stream.switchMap((view) => view.mutationStates))
+	};
+});
+/**
+* Elect this tab into hosting `clientGroupId`'s engine — full main-thread
+* host (ADR-0010) while the lock is held, a mirror over the same channel
+* otherwise — and hand back one `Client` that works unchanged across the
+* transition, plus a `role` stream for observability.
+*/
+const run = (options) => Effect.gen(function* () {
+	const channelName = options.channelName ?? "legation";
+	const locks = options.locks ?? globalLocks();
+	const mirrorScope = yield* Scope.make();
+	const mirrorChannel = yield* make$1(channelName).pipe(Scope.provide(mirrorScope));
+	const mirror = yield* Mirror$1.make({
+		channel: mirrorChannel,
+		mutators: options.mutations
+	}).pipe(Scope.provide(mirrorScope));
+	const viewRef = yield* SubscriptionRef.make(mirror);
+	const roleRef = yield* SubscriptionRef.make("mirror");
+	const becomeHost = Effect.gen(function* () {
+		const hostClientId = options.hostClientId ?? `host-${options.clientGroupId}`;
+		const engine = Subscriptions.counted(yield* ClientEngine.make({
+			clientId: hostClientId,
+			clientGroupId: options.clientGroupId,
+			mutators: options.mutations,
+			...options.queries === void 0 ? {} : { queries: options.queries },
+			...options.syncLoop === void 0 ? {} : { syncLoop: options.syncLoop }
+		}).pipe(Effect.provide(options.dependencies)));
+		const hostChannel = yield* make$1(channelName);
+		yield* EngineHost$1.run({
+			channel: hostChannel,
+			engine,
+			nodes: options.nodes,
+			...options.registry === void 0 ? {} : { registry: options.registry },
+			...options.urls === void 0 ? {} : { urls: options.urls }
+		});
+		yield* Effect.forkScoped(engine.runSync.pipe(Effect.ignore));
+		yield* SubscriptionRef.set(viewRef, ClientView.fromEngine(engine));
+		yield* SubscriptionRef.set(roleRef, "host");
+		yield* Scope.close(mirrorScope, Exit.void);
+	});
+	if (locks === void 0) {
+		yield* Effect.logWarning("ElectedHost: navigator.locks is unavailable — becoming host immediately. This is only correct for a single tab; see the README's topology docs.");
+		yield* becomeHost;
+	} else yield* Effect.forkScoped(electLeader(locks, options.clientGroupId).pipe(Effect.andThen(becomeHost), Effect.tapCause((cause) => Effect.logError("ElectedHost: failed to become host", cause)), Effect.ignore));
+	const view = yield* switchingView(viewRef);
+	return {
+		client: Client.fromView(options.nodes, view, options.urls === void 0 ? {} : { urls: options.urls }),
+		role: SubscriptionRef.changes(roleRef)
+	};
+});
+// src/CacheApiHttpCache.ts
+/**
+* CacheApiHttpCache
+*
+* The browser implementation of core's HTTP cache module (ADR-0008 narrows
+* ADR-0004's stale-marking semantics to exactly this module): a
+* ResponseCacheStore over the Cache API, plus the stale-while-revalidate
+* fetch handler service workers wire into their fetch events.
+*
+* Cache metadata (freshness window, tags) travels in a response header on
+* the stored copy, so entries are self-describing and survive across
+* service-worker restarts. Structural `CacheLike` typing keeps the module
+* testable without browser globals.
+*/
+var CacheApiHttpCache_exports = /* @__PURE__ */ __exportAll({
+	fetchHandler: () => fetchHandler,
+	make: () => make,
+	metaHeader: () => metaHeader,
+	open: () => open
+});
+/** Header carrying the serialized CachedResponseMeta on stored copies. */
+const metaHeader = "x-legation-cache-meta";
+const storeError = (message) => (cause) => new StoreError({
+	message,
+	cause
+});
+const tryCache = (message, run) => Effect.tryPromise({
+	try: run,
+	catch: storeError(message)
+});
+/** Decode a stored meta header; `None` when it is malformed (foreign or corrupt). */
+const parseMeta = Option.liftThrowable((raw) => JSON.parse(decodeURIComponent(raw)));
+const readMeta = (response) => {
+	const raw = response.headers.get(metaHeader);
+	if (raw === null) return void 0;
+	return Option.getOrUndefined(parseMeta(raw));
+};
+/** ResponseCacheStore over one named Cache API cache. */
+const make = (cache) => ({
+	match: (request) => tryCache(`Cache match failed for ${request.url}`, () => cache.match(request)).pipe(Effect.map((response) => {
+		if (response === void 0) return void 0;
+		const meta = readMeta(response);
+		return meta === void 0 ? void 0 : {
+			response,
+			meta
+		};
+	})),
+	put: (request, response, meta) => tryCache(`Cache put failed for ${request.url}`, async () => {
+		const headers = new Headers(response.headers);
+		headers.set(metaHeader, encodeURIComponent(JSON.stringify(meta)));
+		const stored = new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers
+		});
+		await cache.put(request, stored);
+	}),
+	delete: (request) => Effect.asVoid(tryCache(`Cache delete failed for ${request.url}`, () => cache.delete(request))),
+	invalidateTags: (tags) => Effect.gen(function* () {
+		const requests = yield* tryCache("Cache enumeration failed", () => cache.keys());
+		yield* Effect.forEach(requests, (request) => Effect.gen(function* () {
+			const response = yield* tryCache(`Cache match failed for ${request.url}`, () => cache.match(request));
+			const meta = response === void 0 ? void 0 : readMeta(response);
+			if (meta !== void 0 && meta.tags.some((tag) => tags.includes(tag))) yield* tryCache(`Cache delete failed for ${request.url}`, () => cache.delete(request));
+		}), {
+			concurrency: 1,
+			discard: true
+		});
+	})
+});
+/** Open a named cache (defaults to the global `caches`). */
+const open = (name, cacheStorage) => tryCache(`Failed to open cache "${name}"`, () => (cacheStorage ?? globalThis.caches).open(name)).pipe(Effect.map(make));
+/**
+* Build the stale-while-revalidate handler: fresh entries are served from
+* cache, stale-but-unexpired entries are served immediately with a
+* background revalidation, and expired or missing entries reload from the
+* network (caching ok GET responses).
+*/
+const fetchHandler = (options) => {
+	const network = (request) => Effect.tryPromise({
+		try: () => (options.fetch ?? globalThis.fetch)(request),
+		catch: (cause) => new TransportError({
+			message: `Fetch failed for ${request.url}`,
+			cause
+		})
+	});
+	const fetchAndStore = (request, policy) => Effect.gen(function* () {
+		const response = yield* network(request);
+		if (!response.ok) return response;
+		const now = yield* Clock.currentTimeMillis;
+		const timeToLive = policy.timeToLive;
+		const meta = {
+			url: request.url,
+			storedAt: now,
+			staleAt: now + Duration.toMillis(policy.staleTime),
+			expiresAt: timeToLive === void 0 ? void 0 : now + Duration.toMillis(timeToLive),
+			tags: policy.tags ?? []
+		};
+		yield* options.store.put(request, response.clone(), meta);
+		return response;
+	});
+	return (request) => Effect.gen(function* () {
+		const policy = request.method === "GET" ? options.policy(request) : void 0;
+		if (policy === void 0) return {
+			response: yield* network(request),
+			revalidate: void 0
+		};
+		const cached = yield* options.store.match(request);
+		const now = yield* Clock.currentTimeMillis;
+		if (cached !== void 0) {
+			const { meta, response } = cached;
+			if (now < meta.staleAt) return {
+				response,
+				revalidate: void 0
+			};
+			if (meta.expiresAt === void 0 || now < meta.expiresAt) return {
+				response,
+				revalidate: Effect.asVoid(fetchAndStore(request, policy))
+			};
+		}
+		return {
+			response: yield* fetchAndStore(request, policy),
+			revalidate: void 0
+		};
+	});
+};
+// src/HttpCacheInvalidation.ts
+var HttpCacheInvalidation_exports = /* @__PURE__ */ __exportAll({
+	FINE_TAG_ROW_BUDGET: () => 43,
+	collectionChanges: () => collectionChanges,
+	defaultFineTagFor: () => defaultFineTagFor,
+	defaultTagFor: () => defaultTagFor,
+	invalidateOnChanges: () => invalidateOnChanges,
+	tagsFor: () => tagsFor,
+	tagsForObserved: () => tagsForObserved
+});
+/** The default coarse tag convention: `collection:{name}` (`HttpCache.tagFor`, shared with the edge, #206). */
+const defaultTagFor = HttpCache.tagFor;
+/** The default fine, per-row tag convention: `collection:{name}:{id}` (`HttpCache.fineTagFor`). */
+const defaultFineTagFor = HttpCache.fineTagFor;
+const EMPTY_TOUCHED = {
+	collections: [],
+	rows: []
+};
+/** What an engine event touched, or nothing for other events. */
+const touchedBy = (event) => {
+	switch (event._tag) {
+		case "PullCompleted": return {
+			collections: event.collections,
+			rows: event.rows
+		};
+		case "ViewRebuilt": return {
+			collections: event.collections ?? [],
+			rows: []
+		};
+		default: return EMPTY_TOUCHED;
+	}
+};
+/**
+* Derive the change feed from an engine's event stream: the distinct
+* collections and rows each `PullCompleted` (always present) and scoped
+* `ViewRebuilt` (when present) touched, dropping events that touched
+* nothing. Feed the result to {@link invalidateOnChanges}.
+*/
+const collectionChanges = (events) => events.pipe(Stream.map(touchedBy), Stream.filter((touched) => Arr.isReadonlyArrayNonEmpty(touched.collections) || Arr.isReadonlyArrayNonEmpty(touched.rows)));
+/**
+* Fork a scoped fibre that, per emitted change, evicts every cached response
+* tagged for the touched collections (coarse) **and** the touched rows
+* (fine) — `store.invalidateTags`. Invalidation cost stays proportional to
+* the store's tag enumeration — this scans no more than `invalidateTags`
+* already does. Runs until the scope closes; a store error is logged and
+* swallowed, never fatal to the fibre, so a transient cache failure doesn't
+* stop future invalidations.
+*/
+const invalidateOnChanges = (options) => Effect.gen(function* () {
+	const tagFor = options.tagFor ?? defaultTagFor;
+	const fineTagFor = options.fineTagFor ?? defaultFineTagFor;
+	yield* Effect.forkScoped(Stream.runForEach(options.changes, (touched) => {
+		const tags = HttpCache.evictionTags(touched, {
+			tagFor,
+			fineTagFor
+		});
+		return Arr.isReadonlyArrayEmpty(tags) ? Effect.void : options.store.invalidateTags(tags).pipe(Effect.catch((error) => Effect.logWarning("HTTP cache invalidation failed", error)));
+	}));
+});
+/**
+* Build the cache tags for a response that enumerates `rowIds` of
+* `collection`: the coarse tag, plus one fine tag per row when the row count
+* is within {@link FINE_TAG_ROW_BUDGET} — beyond it, the coarse tag alone
+* (`budgetExceeded: true`), since a fine tag per row would blow the header
+* budget the tag rides on. Pure and synchronous, for use building
+* `HttpCachePolicy.tags`; pair with {@link tagsForObserved} to also record
+* the fallback when it happens.
+*/
+const tagsFor = (collection, rowIds, options = {}) => {
+	const coarse = (options.tagFor ?? defaultTagFor)(collection);
+	if (rowIds.length > 43) return {
+		tags: [coarse],
+		budgetExceeded: true
+	};
+	const fineTagFor = options.fineTagFor ?? defaultFineTagFor;
+	return {
+		tags: [coarse, ...rowIds.map((id) => fineTagFor(collection, id))],
+		budgetExceeded: false
+	};
+};
+/**
+* {@link tagsFor}, plus an observable fallback: a response that exceeded the
+* budget is never silently coarse — it logs a warning and increments
+* `legation_cache_tag_budget_exceeded_total` (`Telemetry.cacheTagBudgetExceededTotal`),
+* following the same "safely degraded, but counted" idiom as the engine's
+* other bounded-hub fallbacks (`legation_hints_dropped_total`,
+* `legation_change_collapses_total`).
+*/
+const tagsForObserved = (collection, rowIds, options = {}) => Effect.gen(function* () {
+	const result = tagsFor(collection, rowIds, options);
+	if (result.budgetExceeded) {
+		yield* Effect.logWarning(`HTTP cache tag budget exceeded for collection "${collection}": ${rowIds.length} rows > 43; tagged coarse-only`);
+		yield* Metric.update(Telemetry.cacheTagBudgetExceededTotal, 1);
+	}
+	return result;
+});
+// src/BrowserConnectivity.ts
+var BrowserConnectivity_exports = /* @__PURE__ */ __exportAll({ withBrowserConnectivity: () => withBrowserConnectivity });
+/** The global `navigator` when it reports `onLine`, else undefined (SSR, or a runtime without it). */
+const globalNavigator = () => P.isObjectOrArray(globalThis.navigator) && P.isBoolean(globalThis.navigator.onLine) ? globalThis.navigator : void 0;
+/** Current `navigator.onLine` on the global scope, treating a missing navigator as online. */
+const navigatorOnline = () => globalNavigator()?.onLine ?? true;
+/**
+* Register a DOM event listener on `target` for the scope's lifetime. No-op
+* when `target` is undefined (e.g. server-side rendering).
+*/
+const onEvent = (target, type, handler) => target === void 0 ? Effect.void : Effect.acquireRelease(Effect.sync(() => {
+	target.addEventListener(type, handler);
+}), () => Effect.sync(() => target.removeEventListener(type, handler))).pipe(Effect.asVoid);
+/** The pessimistic combination of two status signals. */
+const worst = (a, b) => a === "disconnected" || b === "disconnected" ? "disconnected" : a === "connecting" || b === "connecting" ? "connecting" : "connected";
+/**
+* Wrap a `ClientTransport` so its connection status combines
+* `navigator.onLine` with the transport's own signal, and a return-to-visible
+* surfaces a poke. Where there is no `window` (a service worker), the
+* navigator signal is probed every `pollInterval` instead of listened for.
+* Scoped: forked fibres and DOM listeners are torn down when the scope closes.
+*/
+const withBrowserConnectivity = (transport, options = {}) => Effect.gen(function* () {
+	const win = globalThis.window;
+	const doc = globalThis.document;
+	const initialOnline = navigatorOnline();
+	const status = yield* SubscriptionRef.make(initialOnline ? "connected" : "disconnected");
+	const statusEvents = yield* Queue.unbounded();
+	const focusPokes = yield* Queue.unbounded();
+	yield* Effect.forkScoped(Stream.fromQueue(statusEvents).pipe(Stream.runForEach((next) => SubscriptionRef.set(status, next))));
+	if (win !== void 0) {
+		yield* onEvent(win, "online", () => Queue.offerUnsafe(statusEvents, "connected"));
+		yield* onEvent(win, "offline", () => Queue.offerUnsafe(statusEvents, "disconnected"));
+	} else if (globalNavigator() !== void 0) {
+		let lastOnline = initialOnline;
+		yield* Effect.forkScoped(Effect.repeat(Effect.sync(() => {
+			const online = navigatorOnline();
+			if (online !== lastOnline) {
+				lastOnline = online;
+				Queue.offerUnsafe(statusEvents, online ? "connected" : "disconnected");
+			}
+		}), Schedule.spaced(options.pollInterval ?? "5 seconds")));
+	}
+	yield* onEvent(doc, "visibilitychange", () => {
+		if (doc?.visibilityState === "visible") Queue.offerUnsafe(focusPokes, { reason: "visibilitychange" });
+	});
+	return {
+		push: transport.push,
+		pull: transport.pull,
+		pokes: Stream.merge(transport.pokes, Stream.fromQueue(focusPokes)),
+		status: Effect.zipWith(SubscriptionRef.get(status), transport.status, worst),
+		statusChanges: Stream.zipLatest(SubscriptionRef.changes(status), transport.statusChanges).pipe(Stream.mapAccum(() => void 0, (previousNavigator, [navigatorStatus, transportStatus]) => {
+			return [navigatorStatus, [previousNavigator === "disconnected" && navigatorStatus === "connected" ? "connected" : worst(navigatorStatus, transportStatus)]];
+		}), Stream.changesWith((a, b) => a === b))
+	};
+});
+// src/BackgroundSync.ts
+var BackgroundSync_exports = /* @__PURE__ */ __exportAll({
+	HostNotReady: () => HostNotReady,
+	defaultReadyTimeout: () => defaultReadyTimeout,
+	defaultTag: () => defaultTag,
+	flush: () => flush,
+	identityUnchecked: () => identityUnchecked,
+	listen: () => listen$1,
+	register: () => register,
+	registerOnJournal: () => registerOnJournal
+});
+/**
+* The tag the library registers and answers. Short on purpose: Chromium
+* refuses over-long tags.
+*/
+const defaultTag = "legation-flush";
+/** How long a `sync` event waits for a host to attach before giving up. */
+const defaultReadyTimeout = "30 seconds";
+/** Whether a probed `sync` member is a `SyncManager`: an object with a `register` method. */
+const isSyncManager = (sync) => P.isObjectOrArray(sync) && "register" in sync && P.isFunction(sync.register);
+/** The registration's `SyncManager`, if the browser gives it one. */
+const syncManagerOf = (registration) => {
+	const sync = registration?.sync;
+	return isSyncManager(sync) ? sync : void 0;
+};
+/** The page's service-worker registration, or `undefined` where there is none. */
+const pageRegistration = Effect.suspend(() => {
+	const container = globalThis.navigator?.serviceWorker;
+	return container === void 0 ? Effect.undefined : Effect.tryPromise(() => container.getRegistration()).pipe(Effect.orElseSucceed(() => void 0));
+});
+/**
+* Ask the browser to wake the worker with the library's `sync` event once
+* connectivity is back. Call it from the page after a journaled mutation, or
+* let `ServiceWorkerHost` do it from the worker (see {@link ListenOptions}).
+*
+* Never fails and never logs above debug level: absence is the common case
+* (Background Sync is Chromium-only), and the journal still flushes on the
+* next connectivity signal. Registering a tag that is already pending is a
+* no-op for the browser, so calling it once per mutation is fine.
+*/
+const register = (options = {}) => Effect.gen(function* () {
+	const tag = options.tag ?? "legation-flush";
+	const registration = yield* options.registration ?? pageRegistration;
+	const sync = syncManagerOf(registration);
+	if (sync === void 0) {
+		yield* Effect.logDebug("Background Sync unavailable; the journal flushes on the next connectivity signal");
+		return "Unsupported";
+	}
+	return yield* Effect.tryPromise(() => sync.register(tag)).pipe(Effect.as("Registered"), Effect.catch((cause) => Effect.logDebug("Background Sync registration refused", cause).pipe(Effect.as("Refused"))));
+});
+/** Whether the worker's own view says the network is down. */
+const navigatorOffline = Effect.sync(() => globalThis.navigator?.onLine === false);
+/**
+* Register the tag for the scope's lifetime whenever `engine`'s journal
+* cannot drain now — the host's side of {@link register}, since in the
+* service-worker topology a page's mutation is journaled in the worker:
+*
+* - a mutation is journaled while {@link RegisterOnJournalOptions.offline}
+*   holds; and
+* - a push fails terminally (`ClientEngine.syncFailures`, after the retry
+*   policy is exhausted) — reachable network, unreachable backend.
+*
+* Never on an online mutation: the sync loop drains those, debounced and
+* compacted, and an online registration would fire `sync` at once and push
+* each write on its own (#246). Chromium only accepts a registration from a
+* worker while a window of the origin is open; a refusal is a debug line.
+*/
+const registerOnJournal = (engine, options = {}) => Effect.gen(function* () {
+	const offline = options.offline ?? navigatorOffline;
+	const registerOn = (stream) => Effect.forkScoped(Stream.runForEach(stream, () => register(options)), { startImmediately: true });
+	yield* registerOn(engine.engineEvents.pipe(Stream.filter((event) => event._tag === "MutationJournaled"), Stream.filterEffect(() => offline)));
+	yield* registerOn(engine.syncFailures.pipe(Stream.filter((failure) => failure.operation === "push")));
+});
+/**
+* The explicit opt-out from the flush's identity check, for an app with **no
+* signed-in identity at all** (every session is the same public principal).
+* The flush then relies on the store's boundary alone: quarantined entries
+* are still unreachable from push, but a store still stamped for a user who
+* signed out in a tab that closed before `Client.reset` ran **would be
+* pushed**. Never pass this in an app that has sign-in.
+*/
+const identityUnchecked = Symbol.for("@thomasfosterau/legation-browser/identityUnchecked");
+/**
+* Flush `engine`'s journal through the ordinary push path, behind the
+* identity check. A journal larger than half the engine's unpulled bound goes
+* in chunks with a pull before each chunk after the first, so a flush may
+* pull (#429); a smaller journal is pushed without pulling. Fails — so the
+* `sync` event rejects and the browser reschedules — on a transport or store
+* failure, with the journal intact. A pull between chunks that fails is a
+* transport failure of the same kind, so the flush never reports `Flushed`
+* over a journal it stopped short of.
+*/
+const flush = (engine, options) => Effect.gen(function* () {
+	if (options.identity !== identityUnchecked) {
+		const current = yield* options.identity;
+		const stamped = yield* engine.identity;
+		if (current === void 0 || stamped !== current) {
+			yield* Effect.logDebug("Background Sync flush skipped: the replica is not stamped for the current identity");
+			return "IdentityChanged";
+		}
+	}
+	return yield* engine.push.pipe(Effect.as("Flushed"), Effect.catchTag("VersionNotSupportedError", () => Effect.succeed("UpdateNeeded")));
+}).pipe(Effect.withSpan("legation.backgroundSync.flush"));
+/** No host attached the listener within its `readyTimeout`. */
+var HostNotReady = class extends Schema.TaggedError()("HostNotReady", {
+	tag: Schema.String,
+	message: Schema.String
+}) {};
+/**
+* Install the `sync` listener on the worker's scope — **synchronously, at the
+* top level of the worker script** (see the module docs for why). Deliberately
+* a plain function rather than an Effect for that reason.
+*
+* ```ts
+* // service-worker.ts, top level
+* const backgroundSync = BackgroundSync.listen({ identity: currentFingerprint });
+* // ... later, once the engine's layers are built:
+* yield* ServiceWorkerHost.start({ backgroundSync, registry, nodes, urls });
+* ```
+*/
+const listen$1 = (options) => {
+	const tag = options.tag ?? "legation-flush";
+	const scope = options.scope ?? globalThis;
+	const readyTimeout = options.readyTimeout ?? "30 seconds";
+	const attached = Effect.runSync(SubscriptionRef.make(Option.none()));
+	const whenAttached = SubscriptionRef.changes(attached).pipe(Stream.filter(Option.isSome), Stream.map((some) => some.value), Stream.runHead, Effect.flatMap((head) => Option.isSome(head) ? Effect.succeed(head.value) : Effect.never), Effect.timeoutOrElse({
+		duration: readyTimeout,
+		orElse: () => Effect.fail(new HostNotReady({
+			tag,
+			message: `No engine host attached within ${Duration.format(Duration.fromInputUnsafe(readyTimeout))}; the browser will reschedule the sync`
+		}))
+	}));
+	const handle = (event) => Effect.runPromise(whenAttached.pipe(Effect.tapError((error) => Effect.logDebug(event.lastChance === true ? `${error.message} (the browser's last chance; the journal flushes on the next connectivity signal)` : error.message)), Effect.flatMap(({ flush: run, services }) => run.pipe(Effect.tapError((error) => error._tag === "TransportError" ? Effect.logDebug(event.lastChance === true ? "Background Sync flush failed on its last chance; the journal flushes on the next connectivity signal" : "Background Sync flush failed; the browser will reschedule it", error) : Effect.logWarning("Background Sync flush failed on the store", error)), Effect.provideContext(services)))));
+	const listener = (event) => {
+		if (event.tag !== tag) return;
+		event.waitUntil(handle(event));
+	};
+	scope.addEventListener?.("sync", listener);
+	const registration = Effect.sync(() => scope.registration);
+	const serve = (engine) => Effect.gen(function* () {
+		const entry = {
+			flush: flush(engine, { identity: options.identity }),
+			services: yield* Effect.context()
+		};
+		yield* Effect.acquireRelease(SubscriptionRef.set(attached, Option.some(entry)), () => SubscriptionRef.update(attached, (current) => Option.isSome(current) && current.value === entry ? Option.none() : current));
+		if (options.registerOnJournal !== false) yield* registerOnJournal(engine, {
+			tag,
+			registration,
+			...options.offline === void 0 ? {} : { offline: options.offline }
+		});
+	});
+	return {
+		tag,
+		serve
+	};
+};
+// src/PushPoke.ts
+var PushPoke_exports = /* @__PURE__ */ __exportAll({ listen: () => listen });
+/** Whether a push is the library's poke; a push whose data cannot be read as text is not. */
+const isLibraryPoke = (event) => {
+	const data = event.data;
+	if (!P.hasProperty(data, "text") || !P.isFunction(data.text)) return false;
+	const text = data.text;
+	return Result.match(Result.try(() => String(text.call(data))), {
+		onSuccess: PushPoke.isPoke,
+		onFailure: () => false
+	});
+};
+/**
+* Install the `push` listener on the worker's scope, synchronously at the top
+* level of the worker script.
+*
+* ```ts
+* // service-worker.ts, top level
+* const backgroundSync = BackgroundSync.listen({ identity: currentFingerprint });
+* const pushPoke = PushPoke.listen({ identity: currentFingerprint });
+* // ... once the engine's layers are built:
+* yield* ServiceWorkerHost.start({ backgroundSync, pushPoke, registry, nodes });
+* ```
+*/
+const listen = (options) => {
+	const scope = options.scope ?? globalThis;
+	const tag = options.tag ?? "legation-flush";
+	const readyTimeout = options.readyTimeout ?? "30 seconds";
+	const timeoutMillis = Duration.toMillis(Duration.fromInputUnsafe(readyTimeout));
+	let attached = Option.none();
+	let waiting = [];
+	const sameIdentity = (engine) => options.identity === identityUnchecked ? Effect.succeed(true) : Effect.all([options.identity, engine.identity.pipe(Effect.orElseSucceed(() => void 0))], { concurrency: 1 }).pipe(Effect.map(([current, stamped]) => current !== void 0 && stamped === current));
+	const act = (engine) => Effect.gen(function* () {
+		if (!(yield* sameIdentity(engine))) {
+			yield* Effect.logDebug("Push-poke skipped: the replica is not stamped for the current identity");
+			return "IdentityChanged";
+		}
+		if (options.action === "pull") return yield* engine.pull.pipe(Effect.as("Pulled"), Effect.catch((error) => Effect.logDebug("Push-poke pull failed; the next connectivity signal pulls", error).pipe(Effect.as("PullFailed"))));
+		return yield* register({
+			tag,
+			registration: Effect.sync(() => scope.registration)
+		});
+	});
+	const handle = () => Option.match(attached, {
+		onSome: (host) => host.run(act(host.engine)),
+		onNone: () => new Promise((resolve) => {
+			const proceed = (host) => {
+				clearTimeout(timer);
+				resolve(host.run(act(host.engine)));
+			};
+			const timer = setTimeout(() => {
+				waiting = waiting.filter((other) => other !== proceed);
+				resolve("HostNotReady");
+			}, timeoutMillis);
+			waiting = [...waiting, proceed];
+		})
+	});
+	const listener = (event) => {
+		if (!isLibraryPoke(event)) return;
+		event.waitUntil(handle());
+	};
+	scope.addEventListener?.("push", listener);
+	const serve = (engine) => Effect.gen(function* () {
+		const host = {
+			engine,
+			run: Effect.runPromiseWith(yield* Effect.context())
+		};
+		yield* Effect.acquireRelease(Effect.sync(() => {
+			attached = Option.some(host);
+			const ready = waiting;
+			waiting = [];
+			ready.forEach((proceed) => proceed(host));
+		}), () => Effect.sync(() => {
+			if (Option.isSome(attached) && attached.value === host) attached = Option.none();
+		}));
+	});
+	return { serve };
+};
+export { BackgroundSync_exports as BackgroundSync, BroadcastMirrorChannel_exports as BroadcastMirrorChannel, BrowserConnectivity_exports as BrowserConnectivity, CacheApiHttpCache_exports as CacheApiHttpCache, ElectedHost_exports as ElectedHost, EngineHost, HttpCacheInvalidation_exports as HttpCacheInvalidation, IndexedDbClientStore_exports as IndexedDbClientStore, Mirror, MirrorChannel, MirrorProtocol, PushPoke_exports as PushPoke, ServiceWorkerHost_exports as ServiceWorkerHost };
+
+//# sourceMappingURL=index.js.map