@thomasfosterau/legation-alchemy-cloudflare 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,613 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.js";
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import { Authorization, Backend, BackendError, Query, StoreError, TransportError } from "@thomasfosterau/legation";
+import { Cvr, FanoutBus, HttpCache, InvalidationBus, Protocol, SyncServer } from "@thomasfosterau/legation/internal";
+import { RuntimeContext } from "alchemy/RuntimeContext";
+import * as Arr from "effect/Array";
+import * as Duration from "effect/Duration";
+import * as Exit from "effect/Exit";
+import * as PubSub from "effect/PubSub";
+import * as R from "effect/Record";
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+import * as Workers from "@alchemy.run/cloudflare/Workers";
+import * as Clock from "effect/Clock";
+import * as HttpServerRequest from "effect/http/HttpServerRequest";
+import * as HttpServerResponse from "effect/http/HttpServerResponse";
+import * as Ref from "effect/Ref";
+import * as Scope from "effect/Scope";
+import * as Queue from "effect/Queue";
+// src/RoomProtocol.ts
+var RoomProtocol_exports = /* @__PURE__ */ __exportAll({
+	decodePullRequest: () => decodePullRequest,
+	decodePushRequest: () => decodePushRequest,
+	decodeReadRequest: () => decodeReadRequest,
+	pokeFrame: () => pokeFrame,
+	routeOf: () => routeOf,
+	routes: () => routes
+});
+/**
+* The room's HTTP routes. A room answers a route by the request path's last
+* segment, so a request forwarded with its base path intact (`/sync/push`)
+* reaches the same route as `/push`.
+*/
+const routes = {
+	push: "/push",
+	pull: "/pull",
+	read: "/read",
+	/** WebSocket upgrade: the poke channel. */
+	socket: "/socket"
+};
+const ROUTES = /* @__PURE__ */ new Set([
+	routes.push,
+	routes.pull,
+	routes.read,
+	routes.socket
+]);
+/**
+* The route a request path addresses: its last segment, when that names one of
+* the {@link routes}.
+*/
+const routeOf = (pathname) => {
+	const route = pathname.slice(pathname.lastIndexOf("/"));
+	return ROUTES.has(route) ? route : void 0;
+};
+/** The single poke frame a room socket sends, as a value to serialize. */
+const pokeFrame = { type: "poke" };
+/** Re-exported request decoders — the room's HTTP bodies are the protocol's. */
+const decodePushRequest = Protocol.decodePushRequest;
+/** The protocol's pull-request decoder. */
+const decodePullRequest = Protocol.decodePullRequest;
+/** The protocol's read-request decoder. */
+const decodeReadRequest = Protocol.decodeReadRequest;
+// src/BindingTransport.ts
+/**
+* BindingTransport
+*
+* A `ClientTransport` that reaches the sync server over a Cloudflare
+* **service binding** (`env.API.fetch`) rather than over the public network.
+*
+* This is the carrier for the ordinary two-Worker shape: a SvelteKit Worker
+* owns the domain and every HTML/SSR request, and the API Worker holding the
+* database is *binding-only* — `workersDev: false`, no custom domain — so the
+* front door stays the single enforcement point for security headers and
+* cache/auth ordering. `RoomTransport` covers the browser (public HTTP plus a
+* poke socket); nothing covered `env.API.fetch(...)`, which is what an SSR
+* render has to use.
+*
+* Two things have to survive the hop, and both are about *identity*:
+*
+* - **The inbound cookie.** The bound Worker resolves the caller's room from
+*   the session, so a call that arrives without the browser's cookie is a
+*   different caller — at best rejected, at worst answered from some other
+*   room. Its CVR store is not the browser's, so its cookie names a
+*   conversation the browser is not in, and the browser's first pull degrades
+*   to the reset path with nothing surfaced.
+* - **The origin.** The bound Worker sees which front door the request came
+*   through — origin checks, per-origin config, logging. A binding call
+*   carries no origin of its own, so the inbound one is forwarded, and a
+*   relative sync path resolves against the inbound URL.
+*
+* The client group id and the pull cookie need no special handling here: they
+* travel in the protocol bodies (`PullRequest.clientGroupId`,
+* `PullResponse.cookie`), which this carrier moves verbatim. That is the whole
+* CVR conversation, and it is what {@link Transport.ClientTransport} promises.
+*
+* There is no poke channel over a binding: a service binding is
+* request/response, and an SSR render pulls once. `pokes` is empty, which
+* costs nothing — pull is the correctness path (ADR-0008) and pokes are a
+* latency optimization for a long-lived client.
+*/
+var BindingTransport_exports = /* @__PURE__ */ __exportAll({ make: () => make$6 });
+/** The headers a binding call carries over from the inbound request. */
+const forwarded = (request) => {
+	const headers = {};
+	const cookie = request.headers.get("cookie");
+	if (cookie !== null && cookie !== "") headers.cookie = cookie;
+	headers.origin = request.headers.get("origin") ?? new URL(request.url).origin;
+	return headers;
+};
+/**
+* Build the transport. Each call is one `binding.fetch` of a JSON POST —
+* no network hop, no public route on the bound Worker.
+*/
+const make$6 = (options) => {
+	const base = new URL(options.path ?? "/sync", options.request.url);
+	const carried = forwarded(options.request);
+	const prefix = base.href.replace(/\/+$/, "");
+	const post = (route) => (body) => Effect.tryPromise({
+		try: async () => {
+			const response = await options.binding.fetch(new Request(`${prefix}${route}`, {
+				method: "POST",
+				body: JSON.stringify(body),
+				headers: {
+					"content-type": "application/json",
+					...carried,
+					...options.headers
+				}
+			}));
+			if (!response.ok) {
+				const detail = await response.json().catch(() => ({}));
+				throw new TransportError({ message: detail.error ?? `binding ${route} answered ${response.status}` });
+			}
+			return await response.json();
+		},
+		catch: (cause) => cause instanceof TransportError ? cause : new TransportError({
+			message: `binding ${route} request failed`,
+			cause
+		})
+	});
+	return {
+		push: post(routes.push),
+		pull: post(routes.pull),
+		read: post(routes.read),
+		pokes: Stream.empty,
+		status: Effect.succeed("connected"),
+		statusChanges: Stream.succeed("connected")
+	};
+};
+// src/D1Executor.ts
+var D1Executor_exports = /* @__PURE__ */ __exportAll({ make: () => make$5 });
+/**
+* Build the executor over a bound D1 client. Needs the `RuntimeContext` of the
+* Worker or Durable Object it runs in (the inner, per-instance phase of an
+* Alchemy Durable Object has it).
+*/
+const make$5 = (db) => Effect.map(Effect.service(RuntimeContext), (runtime) => {
+	/** Run one statement with the captured context; a failed statement is a `BackendError`. */
+	const execute = (operation, statement) => statement.pipe(Effect.provideService(RuntimeContext, runtime), Effect.catchDefect((cause) => Effect.fail(new BackendError({
+		message: `D1 ${operation} failed`,
+		cause
+	}))));
+	return {
+		query: (fragment) => execute("query", db.prepare(fragment.text).bind(...fragment.params).all()).pipe(Effect.map((result) => result.results ?? [])),
+		run: (fragment) => execute("run", db.prepare(fragment.text).bind(...fragment.params).run()).pipe(Effect.asVoid),
+		transaction: (effect) => effect,
+		transactional: false
+	};
+});
+// src/DurableCvrStore.ts
+var DurableCvrStore_exports = /* @__PURE__ */ __exportAll({ make: () => make$4 });
+const KEY_PREFIX = "legation:cvr:";
+/** Build the store over the room's `state.storage`, in the room's runtime context. */
+const make$4 = (storage) => Effect.map(Effect.service(RuntimeContext), (runtime) => {
+	/** Run one storage call with the captured context; a failure is a `StoreError`. */
+	const execute = (operation, call) => call.pipe(Effect.provideService(RuntimeContext, runtime), Effect.catchDefect((cause) => Effect.fail(new StoreError({
+		message: `Durable Object storage ${operation} failed`,
+		cause
+	}))));
+	return {
+		get: (cookie) => execute("get", storage.get(`${KEY_PREFIX}${cookie}`)).pipe(Effect.map((rows) => rows === void 0 ? void 0 : { rows })),
+		set: (cookie, cvr) => execute("put", storage.put(`${KEY_PREFIX}${cookie}`, cvr.rows)),
+		remove: (cookie) => execute("delete", storage.delete(`${KEY_PREFIX}${cookie}`)).pipe(Effect.asVoid)
+	};
+});
+// src/DurableFanoutBroker.ts
+var DurableFanoutBroker_exports = /* @__PURE__ */ __exportAll({ make: () => make$3 });
+/** A shard's answer when its call failed or timed out: nobody to poke. */
+const noRooms = [];
+/** How many shard (or room) calls run at once. */
+const CONCURRENCY = 8;
+/**
+* Build the room's {@link DurableBroker} over the shard namespace; its poke feed
+* lives as long as the scope. Needs the room's `RuntimeContext`, which it
+* captures for its calls.
+*/
+const make$3 = (options) => Effect.gen(function* () {
+	const runtime = yield* RuntimeContext;
+	const hub = yield* Effect.acquireRelease(PubSub.dropping({ capacity: 256 }), (pubsub) => PubSub.shutdown(pubsub));
+	const timeout = options.timeout ?? "5 seconds";
+	/**
+	* One bounded, fire-and-forget call: a failure (the stub's `RpcCallError`
+	* included, which its types do not show) is dropped, since pull is the
+	* correctness path; a call past the bound is logged and dropped.
+	*/
+	const call = (what, effect, fallback) => effect.pipe(Effect.provideService(RuntimeContext, runtime), Effect.exit, Effect.map(Exit.match({
+		onFailure: () => fallback,
+		onSuccess: (value) => value
+	})), Effect.timeoutOrElse({
+		duration: timeout,
+		orElse: () => Effect.as(Effect.logWarning(`DurableFanoutBroker: ${what} timed out; dropped`), fallback)
+	}));
+	return {
+		broker: {
+			register: (roomId, topics, ttl) => Effect.forEach(topics, (topic) => call(`register to shard "${topic}"`, options.shards.getByName(topic).register(roomId, Duration.toMillis(ttl)), void 0), {
+				discard: true,
+				concurrency: CONCURRENCY
+			}),
+			publish: (topics) => Effect.gen(function* () {
+				const answers = yield* Effect.forEach([...topics], (topic) => call(`publish to shard "${topic}"`, options.shards.getByName(topic).publish(), noRooms).pipe(Effect.map((rooms) => ({
+					topic,
+					rooms
+				}))), { concurrency: CONCURRENCY });
+				const matched = Arr.groupBy(Arr.flatMap(answers, ({ topic, rooms }) => Arr.map(rooms, (roomId) => ({
+					roomId,
+					topic
+				}))), ({ roomId }) => roomId);
+				yield* Effect.forEach(R.toEntries(matched), ([roomId, matches]) => call(`poke of room "${roomId}"`, options.poke(roomId, Arr.map(matches, ({ topic }) => topic)), void 0), {
+					discard: true,
+					concurrency: CONCURRENCY
+				});
+			}),
+			pokes: () => Effect.gen(function* () {
+				const subscription = yield* PubSub.subscribe(hub);
+				return { take: PubSub.take(subscription) };
+			})
+		},
+		notify: (topics) => PubSub.publish(hub, topics).pipe(Effect.asVoid)
+	};
+});
+// src/EdgeInvalidation.ts
+/**
+* EdgeInvalidation
+*
+* Server-side cache eviction on Cloudflare from the hints a committed write
+* publishes (#206): the `InvalidationSink`s for a Workers KV read-through cache
+* and for the Workers cache's tag purge, and the hop between the two Workers
+* that a typical deployment has.
+*
+* - {@link kv} deletes `{collection}:{id}` for every row a write touched.
+* - {@link cachePurge} purges the edge cache by tag, with the tag spelling of
+*   `HttpCache` (`collection:{name}`, `collection:{name}:{id}`), the same one
+*   the browser's Cache API invalidation uses: one convention, one place.
+* - {@link forward} and {@link receive} carry what a write touched from the
+*   Worker that commits it to the Worker that holds the cache.
+*
+* ## Where the cache is
+*
+* `cache.purge({ tags })` purges only the calling Worker's own cache. In the
+* usual two-Worker shape the cache belongs to the front door (the SvelteKit
+* Worker that serves every page), while writes land in the API Worker behind
+* a service binding (`BindingTransport`). So the API Worker runs
+* `InvalidationSink.run(EdgeInvalidation.forward(target))` where its bus is,
+* and the front door runs the sinks: its RPC entrypoint passes each payload to
+* {@link receive}. Use an RPC method on a `WorkerEntrypoint` for the target,
+* not a `fetch` route: an RPC method is reachable only through the binding,
+* while a route on the front door's `fetch` is reachable from the internet,
+* and anyone could then purge its cache.
+*
+* ## Failure
+*
+* Fire-and-forget. A failed KV delete, a failed forward and a purge that
+* rejects are logged, and so is a purge that resolves `{ success: false }`:
+* `cache.purge` reports a Cloudflare-side failure that way rather than by
+* rejecting, so a `catch` alone never sees it. None of them fails or delays
+* the write, which has already committed by the time its hint is published.
+* The cache's TTL is the backstop for a lost eviction.
+*/
+var EdgeInvalidation_exports = /* @__PURE__ */ __exportAll({
+	cachePurge: () => cachePurge,
+	encode: () => encode,
+	forward: () => forward,
+	kv: () => kv,
+	kvKey: () => kvKey,
+	receive: () => receive
+});
+/** The default KV key of a row: `{collection}:{id}`. */
+const kvKey = (collection, id) => `${collection}:${id}`;
+/**
+* A sink that deletes each touched row's entry from a KV read-through cache.
+* A failed delete is logged; the entry's TTL is the backstop.
+*/
+const kv = (namespace, options = {}) => {
+	const keyFor = options.keyFor ?? kvKey;
+	return { invalidate: (touched) => Effect.forEach(Arr.dedupe(touched.rows.map((row) => keyFor(row.collection, row.id))), (key) => Effect.tryPromise(() => namespace.delete(key)).pipe(Effect.catch((error) => Effect.logWarning(`EdgeInvalidation: KV delete of "${key}" failed`, error))), {
+		concurrency: options.concurrency ?? 8,
+		discard: true
+	}) };
+};
+/**
+* A sink that purges the edge cache by tag: the coarse tag of every touched
+* collection and the fine tag of every touched row (`HttpCache.evictionTags`).
+* A purge that rejects, and one that resolves `{ success: false }`, is logged.
+*/
+const cachePurge = (cache, options = {}) => {
+	const size = Math.max(1, options.maxTagsPerPurge ?? 30);
+	return { invalidate: (touched) => Effect.forEach(Arr.chunksOf(HttpCache.evictionTags(touched, options), size), (tags) => Effect.tryPromise(() => cache.purge({ tags: [...tags] })).pipe(Effect.flatMap((result) => result.success ? Effect.void : Effect.logWarning("EdgeInvalidation: cache purge reported failure", result.errors ?? [])), Effect.catch((error) => Effect.logWarning("EdgeInvalidation: cache purge failed", error))), {
+		concurrency: 1,
+		discard: true
+	}) };
+};
+/** The wire form of what a write touched. */
+const TouchedJson = Schema.fromJsonString(Schema.Struct({
+	collections: Schema.Array(Schema.String),
+	rows: Schema.Array(Schema.Struct({
+		collection: Schema.String,
+		id: Schema.String
+	}))
+}));
+/** Encode what a write touched for {@link InvalidationTarget.invalidate}. */
+const encode = (touched) => Schema.encodeSync(TouchedJson)({
+	collections: [...touched.collections],
+	rows: touched.rows.map((row) => ({
+		collection: row.collection,
+		id: row.id
+	}))
+});
+/**
+* A sink that forwards what a write touched to the Worker holding the cache.
+* A failed call is logged.
+*/
+const forward = (target) => ({ invalidate: (touched) => Effect.tryPromise(() => target.invalidate(encode(touched))).pipe(Effect.catch((error) => Effect.logWarning("EdgeInvalidation: forwarding an invalidation failed", error))) });
+/**
+* The receiving end of {@link forward}: decode a payload and run `sink` on it.
+* A payload that does not decode is logged and dropped. Call it from the RPC
+* method the binding reaches.
+*/
+const receive = (sink) => (payload) => Option.match(Schema.decodeUnknownOption(TouchedJson)(payload), {
+	onNone: () => Effect.logWarning("EdgeInvalidation: dropped a payload that does not decode"),
+	onSome: (touched) => sink.invalidate(touched)
+});
+// src/FanoutShard.ts
+/**
+* FanoutShard
+*
+* The Durable Object side of ADR-0023's broker, as an Alchemy Durable Object:
+* one shard instance per topic (the object is named BY the topic, so
+* cardinality is managed by the platform — cold topics cost nothing until
+* registered). The shard holds **leases** in its transactional storage:
+* `roomId → expiresAt` for its topic. `register` writes a lease; `publish`
+* answers the unexpired rooms, and expired leases are dropped as publishes pass
+* by — crashed rooms age out with no distributed cleanup.
+*
+* The publishing room pokes the rooms a shard answers
+* (`DurableFanoutBroker`), rather than the shard calling the rooms itself:
+* a shard that called rooms would need the room namespace, and the room needs
+* the shard namespace, which Alchemy's layers cannot provide to each other.
+* Answering the room ids keeps the shard free of any binding.
+*
+* The app declares the class and binds this implementation to it:
+*
+* ```ts
+* export class LegationShard extends Cloudflare.DurableObject<
+*   LegationShard,
+*   FanoutShard.ShardObject
+* >()("LegationShard") {}
+*
+* export const LegationShardLive = LegationShard.make(FanoutShard.make());
+* ```
+*/
+var FanoutShard_exports = /* @__PURE__ */ __exportAll({
+	leases: () => leases,
+	make: () => make$2
+});
+const LEASE_PREFIX = "legation:lease:";
+/** The lease operations, storage-backed (exported for direct testing). */
+const leases = {
+	register: (storage, roomId, ttlMillis, now) => storage.put(`${LEASE_PREFIX}${roomId}`, now + ttlMillis),
+	/** The unexpired room ids, in listing order; expired entries are deleted as a side effect. */
+	live: (storage, now) => Effect.gen(function* () {
+		const entries = [...yield* storage.list({ prefix: LEASE_PREFIX })];
+		const expired = entries.filter(([, expiresAt]) => expiresAt <= now).map(([key]) => key);
+		if (Arr.isReadonlyArrayNonEmpty(expired)) yield* storage.delete(expired);
+		return entries.filter(([, expiresAt]) => expiresAt > now).map(([key]) => key.slice(15));
+	})
+};
+/**
+* The shard's Durable Object implementation, for `LegationShard.make(...)`:
+* its state is resolved at init, its leases read and written per call.
+*/
+const make$2 = () => Effect.gen(function* () {
+	const state = yield* Workers.DurableObjectState;
+	return Effect.succeed({
+		register: (roomId, ttlMillis) => Effect.flatMap(Clock.currentTimeMillis, (now) => leases.register(state.storage, roomId, ttlMillis, now)),
+		publish: () => Effect.flatMap(Clock.currentTimeMillis, (now) => leases.live(state.storage, now))
+	});
+});
+// src/Room.ts
+/**
+* Room
+*
+* The per-user Durable Object of ADR-0022's reference topology, as an Alchemy
+* Durable Object: it runs the sync `Server` for one user — push/pull/read over
+* stateless HTTP (hibernation-proof), CVRs in the object's transactional
+* storage (co-located with the user), a `FanoutBus` over the topic shards for
+* cross-room fan-out, and WebSockets that carry exactly one thing: contentless
+* poke frames, sent when a publish matches the room's leases, so hibernated
+* sockets cost nothing between writes.
+*
+* The app declares the class (the shard class beside it) and binds
+* {@link make} to it, resolving the bindings the room needs at init:
+*
+* ```ts
+* export class LegationRoom extends Cloudflare.DurableObject<LegationRoom, Room.RoomObject>()(
+*   "LegationRoom"
+* ) {}
+*
+* export const LegationRoomLive = LegationRoom.make(
+*   Effect.gen(function* () {
+*     const db = yield* Cloudflare.D1.QueryDatabase(AppDatabase);
+*     return yield* Room.make({
+*       nodes,
+*       backend: Effect.map(D1Executor.make(db), (executor) => SqlBackend.make({ executor, ... })),
+*       policy: Effect.succeed(Authorization.policy({ ... })),
+*       shards: LegationShard,
+*     });
+*   })
+* );
+* ```
+*
+* The server is built once per in-memory instance, in the object's
+* per-instance phase (Alchemy runs it under `blockConcurrencyWhile` when the
+* object is constructed, a wake from hibernation included).
+*/
+var Room_exports = /* @__PURE__ */ __exportAll({ make: () => make$1 });
+/** Run an effect on the room's clock: the configured one, or the real clock when none is set. */
+const onRoomClock = (clock, effect) => clock === void 0 ? effect : effect.pipe(Effect.provideService(Clock.Clock, clock));
+/** A failed protocol request, answered as a 400 carrying the error's message. */
+const badRequest = (error) => Effect.succeed(HttpServerResponse.jsonUnsafe({ error: error.message }, { status: 400 }));
+/** Answer one JSON protocol request with the matching handler operation. */
+const answer = (handle) => handle.pipe(Effect.map((response) => HttpServerResponse.jsonUnsafe(response)), Effect.catchTags({
+	ProtocolError: badRequest,
+	TransportError: badRequest,
+	VersionNotSupportedError: badRequest
+}));
+const notFound = HttpServerResponse.text("not found", { status: 404 });
+/**
+* The room's Durable Object implementation, for `LegationRoom.make(...)`. Init
+* resolves the object's state, its own namespace (to poke sibling rooms) and
+* the shard namespace; the per-instance phase builds the sync server.
+*/
+const make$1 = (config) => Effect.gen(function* () {
+	const state = yield* Workers.DurableObjectState;
+	const rooms = yield* Workers.DurableObjectScope;
+	const shards = yield* config.shards;
+	return onRoomClock(config.clock, Effect.gen(function* () {
+		const scope = yield* Scope.make();
+		const runtime = yield* RuntimeContext;
+		const roomId = state.id.name ?? state.id.toString();
+		/** Every poke socket gets one contentless frame. */
+		const nudgeSockets = Effect.flatMap(state.getWebSockets(), (sockets) => Effect.forEach(sockets, (socket) => socket.send(JSON.stringify(pokeFrame)), {
+			concurrency: "unbounded",
+			discard: true
+		}));
+		return yield* Effect.gen(function* () {
+			const durable = yield* make$3({
+				shards,
+				poke: (target, topics) => target === roomId ? deliver(topics) : rooms.getByName(target).poke(topics),
+				timeout: config.publishTimeout
+			});
+			/** An inbound poke: the bus's matcher pokes the affected groups' pull loops. */
+			const deliver = (topics) => Effect.andThen(durable.notify(topics), nudgeSockets);
+			const subsetsRef = yield* Ref.make(Effect.succeed([]));
+			const bus = yield* FanoutBus.make({
+				roomId,
+				broker: durable.broker,
+				nodes: config.nodes,
+				subsets: Ref.get(subsetsRef).pipe(Effect.flatten),
+				heartbeat: config.heartbeat ?? "30 seconds",
+				timeout: config.publishTimeout
+			});
+			const cvrs = yield* make$4(state.storage);
+			let build = SyncServer.makeWithIntrospection.pipe(Effect.provideService(Backend.Backend, yield* config.backend), Effect.provideService(Authorization.AuthPolicy, yield* config.policy), Effect.provideService(Cvr.CvrStore, cvrs), Effect.provideService(InvalidationBus.InvalidationBus, bus));
+			if (config.identity !== void 0) build = build.pipe(Effect.provideService(Authorization.IdentityResolver, yield* config.identity));
+			if (config.queries !== void 0) build = build.pipe(Effect.provideService(Query.QueryResolver, yield* config.queries));
+			const { handler, introspection } = yield* build;
+			yield* Ref.set(subsetsRef, introspection.groups.pipe(Effect.map((groups) => groups.flatMap((group) => group.subsets))));
+			return {
+				fetch: onRoomClock(config.clock, Effect.gen(function* () {
+					const request = yield* HttpServerRequest.HttpServerRequest;
+					const route = routeOf(new URL(request.url, "https://room").pathname);
+					if (route === routes.socket) {
+						const [response] = yield* Workers.upgrade();
+						return response;
+					}
+					if (route === routes.push) {
+						const body = yield* request.json;
+						return yield* answer(Effect.flatMap(decodePushRequest(body), (decoded) => handler.handlePush(decoded)));
+					}
+					if (route === routes.pull) {
+						const body = yield* request.json;
+						return yield* answer(Effect.flatMap(decodePullRequest(body), (decoded) => handler.handlePull(decoded)));
+					}
+					if (route === routes.read) {
+						const body = yield* request.json;
+						return yield* answer(Effect.flatMap(decodeReadRequest(body), (decoded) => handler.handleRead(decoded)));
+					}
+					return notFound;
+				})),
+				poke: (topics) => onRoomClock(config.clock, deliver(topics).pipe(Effect.provideService(RuntimeContext, runtime))),
+				webSocketMessage: () => Effect.void,
+				webSocketClose: () => Effect.void
+			};
+		}).pipe(Scope.provide(scope));
+	}));
+});
+// src/RoomTransport.ts
+/**
+* RoomTransport
+*
+* The browser-side `ClientTransport` for the room topology: push, pull,
+* and fallthrough reads travel as stateless HTTP POSTs (each one wakes the
+* hibernated room, is answered, and lets it sleep again), while a single
+* WebSocket carries the room's contentless poke frames. The socket
+* reconnects with backoff and its state drives the connection status; sync
+* stays correct over HTTP alone (a dead socket only delays pokes — the
+* pull interval remains the safety net).
+*
+* Runs on standard `fetch`/`WebSocket` globals — no Workers types — so the
+* same transport serves browsers, service workers, and Node 22+.
+*/
+var RoomTransport_exports = /* @__PURE__ */ __exportAll({ make: () => make });
+const post = (options, route) => (body) => Effect.tryPromise({
+	try: async () => {
+		const response = await fetch(`${options.url}${route}`, {
+			method: "POST",
+			body: JSON.stringify(body),
+			headers: {
+				"content-type": "application/json",
+				...options.headers
+			}
+		});
+		if (!response.ok) {
+			const detail = await response.json().catch(() => ({}));
+			throw new TransportError({ message: detail.error ?? `room ${route} answered ${response.status}` });
+		}
+		return await response.json();
+	},
+	catch: (cause) => cause instanceof TransportError ? cause : new TransportError({
+		message: `room ${route} request failed`,
+		cause
+	})
+});
+/**
+* Build the transport. The poke socket dials lazily on first subscription
+* and re-dials with linear backoff; each frame becomes one contentless
+* poke.
+*/
+const make = (options) => {
+	const socketUrl = `${options.url.replace(/^http/, "ws")}${routes.socket}`;
+	return {
+		push: (request) => post(options, routes.push)(request),
+		pull: (request) => post(options, routes.pull)(request),
+		read: (request) => post(options, routes.read)(request),
+		pokes: Stream.callback((queue) => Effect.acquireRelease(Effect.sync(() => {
+			let socket;
+			let closed = false;
+			let attempt = 0;
+			const dial = () => {
+				if (closed) return;
+				socket = new WebSocket(socketUrl);
+				socket.onmessage = () => {
+					attempt = 0;
+					Queue.offer(queue, {}).pipe(Effect.runPromise);
+				};
+				socket.onclose = () => {
+					if (closed) return;
+					attempt += 1;
+					const delay = Math.min(1e3 * attempt, options.maxReconnectDelayMillis ?? 1e4);
+					setTimeout(dial, delay);
+				};
+				socket.onerror = () => socket?.close();
+			};
+			dial();
+			return () => {
+				closed = true;
+				socket?.close();
+			};
+		}), (close) => Effect.sync(close))),
+		status: Effect.succeed("connected"),
+		statusChanges: Stream.succeed("connected")
+	};
+};
+// src/Worker.ts
+var Worker_exports = /* @__PURE__ */ __exportAll({ routeSync: () => routeSync });
+/**
+* Route one request: `Option.none()` for a path outside the base, a 404 for an
+* unknown route under it, a 401 for an anonymous caller, otherwise the room's
+* own response.
+*/
+const routeSync = (config) => Effect.gen(function* () {
+	const request = yield* HttpServerRequest.HttpServerRequest;
+	const base = config.basePath ?? "/sync";
+	const pathname = new URL(request.url, "https://worker").pathname;
+	if (!pathname.startsWith(`${base}/`)) return Option.none();
+	if (routeOf(pathname) === void 0 || pathname.lastIndexOf("/") !== base.length) return Option.some(HttpServerResponse.text("not found", { status: 404 }));
+	const roomId = yield* config.roomIdOf(request);
+	if (roomId === void 0) return Option.some(HttpServerResponse.text("unauthorized", { status: 401 }));
+	return Option.some(yield* config.rooms.getByName(roomId).fetch(request));
+});
+export { BindingTransport_exports as BindingTransport, D1Executor_exports as D1Executor, DurableCvrStore_exports as DurableCvrStore, DurableFanoutBroker_exports as DurableFanoutBroker, EdgeInvalidation_exports as EdgeInvalidation, FanoutShard_exports as FanoutShard, Room_exports as Room, RoomProtocol_exports as RoomProtocol, RoomTransport_exports as RoomTransport, Worker_exports as Worker };
+
+//# sourceMappingURL=index.js.map