@gjermundgaraba/effect-actions-cloudflare 0.22.0 → 0.23.0

package/dist/ActionDurableObject.d.mts

@@ -194,6 +194,12 @@ export interface Handlers<S = never> {
  * Guide: `docs/ActionDurableObject-own-class.md` in this package.
  */
 export declare const handlers: <S = never, SE = never, SR extends State | Alarm | Tasks | Event.Events | Action.Idempotency = never, A = never, E = never, R extends Allowed<A, S> = never, AE = never, AR extends S | State | Alarm | Tasks | Event.Events | Action.Idempotency | Scope.Scope = never, CA = never, CE = never, CR extends RpcServer.Protocol | S | State | Alarm | Tasks | Event.Events | Action.Idempotency = never>(ctx: DurableObjectState, options: Options<S, SE, SR, A, E, R, AE, AR, CA, CE, CR>) => Handlers<S>;
+/**
+ * An instance of a class `make` returns: a Durable Object with the handlers it defines, each
+ * taking the runtime's own arguments, so a class extending it overrides them as `Handlers`
+ * declares them, returning a promise, and reaches `make`'s through `super`, its `env` the one its
+ * `services` function takes.
+ */
 /**
  * An instance of a class `make` returns: a Durable Object with the handlers it defines, each
  * taking the runtime's own arguments, so a class extending it overrides them as `Handlers`

package/dist/ActionDurableObject.mjs

@@ -24,23 +24,23 @@ const handlersOf = (ctx, options) => {
 	const { waits, wakeDue } = makeWaits(schedule);
 	const tasks = makeTasks(schedule, options.tasks ?? {});
 	const build = Effect.gen(function* () {
-		const memoMap = yield* Layer.makeMemoMap;
+		const sharedMemoMap = yield* Layer.makeMemoMap;
 		const scope = yield* Scope.make();
 		return yield* Effect.gen(function* () {
-			const context = yield* Layer.buildWithMemoMap(services.pipe(Layer.provideMerge(Layer.mergeAll(Layer.succeed(Alarm)(alarmOf(schedule)), Layer.succeed(Waits)(waits), Layer.succeed(Tasks)(tasks.tasks), layerEvents, layerIdempotency(ctx))), Layer.provideMerge(state), Layer.provideMerge(Layer.merge(Layer.succeed(Scheduler.Scheduler)(scheduler), options.placed === void 0 ? Layer.empty : layerInputCheck(options.placed, ctx.id.name)))), memoMap, scope);
+			const context = yield* Layer.buildWithMemoMap(services.pipe(Layer.provideMerge(Layer.mergeAll(Layer.succeed(Alarm)(alarmOf(schedule)), Layer.succeed(Waits)(waits), Layer.succeed(Tasks)(tasks.tasks), layerEvents, layerIdempotency(ctx))), Layer.provideMerge(state), Layer.provideMerge(Layer.merge(Layer.succeed(Scheduler.Scheduler)(scheduler), options.placed === void 0 ? Layer.empty : layerInputCheck(options.placed, ctx.id.name)))), sharedMemoMap, scope);
 			const given = Layer.succeedContext(context);
 			yield* schedule.restore;
 			const call = calls === void 0 ? async () => {
 				throw new Error("This Durable Object serves no rpcs over its stub: give handlers or make a calls Layer");
 			} : yield* Effect.gen(function* () {
 				const stub = yield* Effect.provideContext(makeStubProtocol, context);
-				yield* Layer.buildWithMemoMap(calls.pipe(Layer.provide(Layer.succeed(RpcServer.Protocol)(stub.protocol)), Layer.provide(given)), memoMap, scope);
+				yield* Layer.buildWithMemoMap(calls.pipe(Layer.provide(Layer.succeed(RpcServer.Protocol)(stub.protocol)), Layer.provide(given)), sharedMemoMap, scope);
 				yield* stub.served;
 				return async (request) => await Effect.runPromise(stub.serve(request));
 			});
-			const sockets = yield* Layer.buildWithMemoMap(Sockets.layer.pipe(Layer.provide(given)), memoMap, scope);
+			const sockets = yield* Layer.buildWithMemoMap(Sockets.layer.pipe(Layer.provide(given)), sharedMemoMap, scope);
 			const serve = routes === void 0 ? async () => new Response(null, { status: 404 }) : yield* Effect.gen(function* () {
-				const routed = yield* Layer.buildWithMemoMap(routes.pipe(Layer.provideMerge(Layer.succeedContext(Context.merge(context, sockets))), Layer.provide(HttpServer.layerServices), Layer.provideMerge(HttpRouter.layer)), memoMap, scope);
+				const routed = yield* Layer.buildWithMemoMap(routes.pipe(Layer.provideMerge(Layer.succeedContext(Context.merge(context, sockets))), Layer.provide(HttpServer.layerServices), Layer.provideMerge(HttpRouter.layer)), sharedMemoMap, scope);
 				return yield* Effect.sync(() => HttpEffect.toWebHandlerWith(routed)(Context.get(routed, HttpRouter.HttpRouter).asHttpEffect(), options.disableLogger === true ? void 0 : HttpMiddleware.logger));
 			});
 			return {
@@ -89,8 +89,8 @@ const handlersOf = (ctx, options) => {
 		if (!building) start();
 		return await promise;
 	};
-	const provided = ({ context }, effect) => Effect.scopedWith((scope) => Effect.provideContext(effect, context.pipe(Context.add(Scope.Scope, scope), Context.add(Layer.CurrentMemoMap, Layer.makeMemoMapUnsafe()))));
-	const run = async (effect) => await withBuilt(async (built) => await Effect.runPromise(provided(built, effect)));
+	const providedPerCall = ({ context }, effect) => Effect.scopedWith((scope) => Effect.provideContext(effect, context.pipe(Context.add(Scope.Scope, scope), Context.add(Layer.CurrentMemoMap, Layer.makeMemoMapUnsafe()))));
+	const run = async (effect) => await withBuilt(async (built) => await Effect.runPromise(providedPerCall(built, effect)));
 	const dispatch = async (event) => {
 		await withBuilt(async ({ sockets }) => {
 			await Effect.runPromise(Effect.asVoid(event(sockets)));

package/dist/alarm.mjs

@@ -1,7 +1,6 @@
 import { State } from "./state.mjs";
 import { Clock, Context, DateTime, Effect, Exit, Layer, Option, Schema, Semaphore } from "effect";
 // src/durable/alarm.ts
-/** Where the object's alarm times are kept, one key per owner. */
 const alarmPrefix = "effect-actions/alarm/";
 const keyOf = (owner) => `${alarmPrefix}${owner}`;
 const Kept = Schema.Struct({
@@ -12,15 +11,10 @@ const keptOf = Schema.decodeUnknownOption(Kept);
 const backoffRetries = 6;
 const hour = 36e5;
 const retryDelay = (failures) => failures > backoffRetries ? hour : 2e3 * 2 ** (failures - 1);
-/**
-* The object's alarm times, one per owner, kept in its storage: the runtime's one alarm is set
-* for the earliest, and `runDue` runs each owner whose time has come. `handlers` and `make` make
-* one per instance, which its `Alarm` and its `alarm` handler share.
-*/
 const makeSchedule = (state) => {
 	const { storage } = state;
 	const lock = Semaphore.makeUnsafe(1);
-	const running = /* @__PURE__ */ new Set();
+	const runningInThisInstance = /* @__PURE__ */ new Set();
 	const read = (owner) => Effect.map(Effect.promise(async () => await storage.get(keyOf(owner))), keptOf);
 	const times = Effect.promise(async () => await storage.list({ prefix: alarmPrefix })).pipe(Effect.map((listed) => [...listed].flatMap(([key, value]) => Option.match(keptOf(value), {
 		onNone: () => [],
@@ -41,29 +35,15 @@ const makeSchedule = (state) => {
 	return {
 		rearm,
 		restore: lock.withPermits(1)(Effect.flatMap(Effect.promise(async () => await storage.getAlarm()), (alarm) => alarm === null ? Effect.flatMap(times, (kept) => kept.length === 0 ? Effect.void : rearm) : Effect.void)),
-		/**
-		* Keeps `at` as the owner's time, in place of any: set as the owner's run fails, it gives way
-		* to that run's retry where the retry is earlier.
-		*/
 		set: (owner, at) => lock.withPermits(1)(Effect.flatMap(read(owner), (kept) => Option.exists(kept, (held) => held.at === at && held.failures === 0) ? Effect.void : Effect.andThen(keep(owner, {
 			at,
 			failures: 0
 		}), rearm))),
-		/**
-		* Keeps `at` as the owner's time unless an earlier one is kept, a retry due included: the
-		* mark of the owner's run under way is no time, so a time set from the run is kept.
-		*/
-		setBy: (owner, at) => lock.withPermits(1)(Effect.flatMap(read(owner), (kept) => Option.exists(kept, (held) => held.at <= at && (held.failures === 0 || !running.has(owner))) ? Effect.void : Effect.andThen(keep(owner, {
+		setBy: (owner, at) => lock.withPermits(1)(Effect.flatMap(read(owner), (kept) => Option.exists(kept, (held) => held.at <= at && (held.failures === 0 || !runningInThisInstance.has(owner))) ? Effect.void : Effect.andThen(keep(owner, {
 			at,
 			failures: 0
 		}), rearm))),
 		clear: (owner) => lock.withPermits(1)(Effect.andThen(Effect.promise(async () => await storage.delete(keyOf(owner))), rearm)),
-		/**
-		* Runs each owner whose time has come as its turn comes, removing its time once its run
-		* succeeds unless one was set or cleared as it ran: one that fails is logged and retried, 2
-		* seconds later, doubling, six times, then hourly, unless cleared as it ran or a time set as
-		* it ran is earlier.
-		*/
 		runDue: (owners) => Effect.gen(function* () {
 			const now = yield* Clock.currentTimeMillis;
 			const kept = yield* times;
@@ -82,7 +62,7 @@ const makeSchedule = (state) => {
 					yield* keep(owner, mark).pipe(Effect.andThen(rearm), Effect.andThen(Effect.promise(async () => {
 						await storage.sync();
 					})));
-					running.add(owner);
+					runningInThisInstance.add(owner);
 					return {
 						...current,
 						mark,
@@ -100,7 +80,7 @@ const makeSchedule = (state) => {
 				if (Exit.isFailure(exit)) yield* Effect.logError(`The alarm of ${owner} failed: retried in ${retryDelay(attempt)} ms`, exit.cause);
 				const endedAt = yield* Clock.currentTimeMillis;
 				yield* lock.withPermits(1)(Effect.gen(function* () {
-					running.delete(owner);
+					runningInThisInstance.delete(owner);
 					const current = yield* stored;
 					const isMark = current?.at === mark.at && current.failures === mark.failures;
 					if (Exit.isSuccess(exit)) {
@@ -115,15 +95,13 @@ const makeSchedule = (state) => {
 					if (isMark || retry.at < current.at) yield* keep(owner, retry);
 				}));
 			}).pipe(Effect.ensuring(Effect.sync(() => {
-				running.delete(owner);
+				runningInThisInstance.delete(owner);
 			}))), { discard: true });
 			yield* lock.withPermits(1)(rearm);
 		})
 	};
 };
-/** The owner the application's `alarm` option runs as. */
 const applicationOwner = "application";
-/** The application's alarm over `schedule`, the instance's. */
 const alarmOf = (schedule) => Alarm.of({
 	set: (at) => schedule.setBy(applicationOwner, DateTime.toEpochMillis(at)),
 	clear: schedule.clear(applicationOwner)

package/dist/batches.mjs

@@ -5,6 +5,5 @@ import { Array, Effect } from "effect";
 * most 128 keys each, as Cloudflare's storage API documents, though local workerd takes more.
 */
 const batches = (keys) => Array.chunksOf(keys, 128);
-/** Deletes `keys` from `storage`, one batch per call. */
 const deleted = (storage, keys) => Effect.forEach(batches(keys), (batch) => Effect.promise(async () => await storage.delete([...batch])), { discard: true });
 export { batches, deleted };

package/dist/calls.mjs

@@ -2,19 +2,8 @@ import { Effect, Predicate, Queue, Schema } from "effect";
 import { RpcMessage, RpcServer } from "effect/rpc";
 import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
 // src/durable/calls.ts
-/**
-* The codec of the stub's values: each schema's type to its plain form, `Schema.toCodecIso`, which
-* Workers RPC's structured clone carries as it is, a `Date`, bytes, `undefined` and a `Map` among
-* them, where JSON would encode them again. An `Exit`, a `Cause` and an `Option` encode to their
-* tagged objects, a class instance to its fields.
-*/
 const codecFor = Schema.toCodecIso;
 const encodeDefect = Schema.encodeSync(codecFor(Schema.Defect()));
-/**
-* A unary `RpcServer.Protocol` over the object's stub, passing values, modeled on Effect's HTTP
-* protocol: one call is one client, its requests and their responses, then its end. `serve`
-* answers one call of `effectActionsRpc`, and `served` dies unless a server runs on `protocol`.
-*/
 const makeStubProtocol = Effect.gen(function* () {
 	const context = yield* Effect.context();
 	let running = false;

package/dist/events.mjs

@@ -18,10 +18,6 @@ const positionOf = Schema.decodeUnknownOption(Position);
 const storedOf = Schema.decodeUnknownOption(Stored);
 const encodeStored = Schema.encodeSync(Stored);
 const seqWidth = 16;
-/**
-* A log's storage in the object's, under `effect-actions/log/<event>/`: its position, and each
-* entry by its sequence number, its data encoded as the event's payload JSON.
-*/
 const storageLog = (storage, event) => {
 	const prefix = `effect-actions/log/${event.name}/`;
 	const positionKey = `${prefix}meta`;
@@ -85,10 +81,6 @@ const epochKey = `${revisionPrefix}epoch`;
 const countPrefix = `${revisionPrefix}count/`;
 const epochOf = Schema.decodeUnknownOption(Schema.String);
 const countOf = Schema.decodeUnknownOption(Schema.Int);
-/**
-* Current sources' revisions in the object's storage, under `effect-actions/revisions/`: an
-* epoch made as the object first builds, and a counter by name.
-*/
 const storageRevisions = (storage) => {
 	const get = (name) => Effect.map(Effect.promise(async () => await storage.get(`${countPrefix}${name}`)), (found) => Option.getOrElse(countOf(found), () => 0));
 	return Effect.gen(function* () {
@@ -107,13 +99,6 @@ const storageRevisions = (storage) => {
 		};
 	});
 };
-/**
-* The object's `Event.Events`, which `handlers` and `make` provide to the services, calls and
-* routes: each log source's log kept in the object's storage, under `effect-actions/log/`, each
-* current source's revisions beside it, so a cursor outlives an eviction, and a check or current
-* source's subscribers read again when notified, not on its `nextPoll`, a timer that would keep the
-* object from hibernating. Its rules are on `handlers`.
-*/
 const layerEvents = Layer.effect(Event.Events)(Effect.flatMap(State, ({ storage }) => Effect.flatMap(storageRevisions(storage), (revisions) => {
 	const named = /* @__PURE__ */ new Map();
 	return Event.makeEvents({

package/dist/frames.mjs

@@ -2,32 +2,29 @@ import { Effect, Schema } from "effect";
 import { RpcSerialization } from "effect/rpc";
 // src/durable/frames.ts
 const socketPrefix = "effect-actions/socket#";
-/** The tag a socket carries for its id, unique among the object's sockets. */
 const socketTag = (id) => `${socketPrefix}${id}`;
-/** The id a socket's tags give it, or 0, which no socket is given, for one no protocol accepted. */
 const socketIdOf = (tags) => {
 	const tag = tags.find((found) => found.startsWith(socketPrefix));
 	return tag === void 0 ? 0 : Number(tag.slice(22));
 };
-/** The tag a socket carries for the `layerWebSocket` path that accepted it. */
 const groupTag = (path) => `effect-actions/rpc:${path}`;
-/** A request's id on the wire, a finite number or a string, which a client tells apart. */
 const RequestId = Schema.Union([Schema.String, Schema.Finite]);
-/** The object's JSON parser, which keeps no state between frames. */
 const parser = RpcSerialization.json.makeUnsafe();
-/** Closes `socket` with `code`, or with none, unless it is already closing. */
 const closeQuietly = (socket, code, reason) => {
 	try {
 		if (code === void 0) socket.close();
 		else socket.close(code, reason);
-	} catch {}
+	} catch {
+		return;
+	}
 };
-/** Sends `frame` to the socket `id`, if one holds it and takes it: one the object closed does not. */
 const sendFrame = (state, id, frame) => Effect.sync(() => {
 	const encoded = parser.encode(frame);
 	if (encoded === void 0) return;
 	try {
 		for (const socket of state.getWebSockets(socketTag(id))) socket.send(encoded);
-	} catch {}
+	} catch {
+		return;
+	}
 });
 export { RequestId, closeQuietly, groupTag, parser, sendFrame, socketIdOf, socketTag };

package/dist/idempotency.mjs

@@ -2,19 +2,13 @@ import { deleted } from "./batches.mjs";
 import { Clock, Effect, Layer, Option, Schema } from "effect";
 import * as Action from "@gjermundgaraba/effect-actions/Action";
 // src/durable/idempotency.ts
-/** Where the object's kept answers live, one key per action, caller's principal and idempotency key. */
 const keptPrefix = "effect-actions/idempotency/";
 const hour = 36e5;
 const page = 128;
 const keptOf = Schema.decodeUnknownOption(Action.Idempotency.Kept);
-/**
-* `Action.Idempotency` over the object's storage: each answer kept 24 hours, through
-* hibernation, eviction and deployments, and deleted once its day is past as a later one is kept,
-* at most once an hour, so an object given no further key keeps its last day's answers.
-*/
 const layerIdempotency = (state) => Layer.sync(Action.Idempotency)(() => {
 	let prunedAt = -Infinity;
-	const prune = Effect.gen(function* () {
+	const pruneHourlyOnWrite = Effect.gen(function* () {
 		const now = yield* Clock.currentTimeMillis;
 		if (now - prunedAt < hour) return;
 		prunedAt = now;
@@ -34,7 +28,7 @@ const layerIdempotency = (state) => Layer.sync(Action.Idempotency)(() => {
 		get: (id) => Effect.map(Effect.promise(async () => await state.storage.get(`${keptPrefix}${id}`)), (stored) => Option.getOrUndefined(keptOf(stored))),
 		set: (id, kept) => Effect.andThen(Effect.promise(async () => {
 			await state.storage.put(`${keptPrefix}${id}`, kept);
-		}), prune)
+		}), pruneHourlyOnWrite)
 	});
 });
 export { layerIdempotency };

package/dist/placed.mjs

@@ -37,10 +37,6 @@ const reaching = (placement, namespace) => {
 		return HttpClient.transform(fetching, (sent) => Effect.provideService(sent, FetchHttpClient.Fetch, async (url, init) => await stub.fetch(url, init)));
 	});
 };
-/**
-* The input check of an object named `name`, given `placement`: an input of one of its contracts
-* whose key names another object is refused.
-*/
 const layerInputCheck = (placement, name) => {
 	const contracts = /* @__PURE__ */ new Set([...placement.binding.actions, ...placement.binding.events]);
 	return Layer.succeed(Action.InputCheck)((contract, input) => {

package/dist/sockets.d.mts

@@ -2,11 +2,8 @@ import { State } from "./state.mjs";
 import { Context, Effect, Layer } from "effect";
 import { HttpRouter, HttpServerResponse } from "effect/http";
 import { RpcServer } from "effect/rpc";
-/** What a protocol does with the events of the sockets carrying its tag. */
 interface Receiver {
-  /** Hands a message to the protocol. */
   readonly message: (socket: WebSocket, data: string | ArrayBuffer) => Effect.Effect<void>;
-  /** Tells the protocol the socket closed or failed. */
   readonly close: (socket: WebSocket) => Effect.Effect<void>;
 }
 declare const Sockets_base: Context.ServiceClass<Sockets, "effect-actions-cloudflare/ActionDurableObject/Sockets", {
@@ -41,7 +38,6 @@ declare const Sockets_base: Context.ServiceClass<Sockets, "effect-actions-cloudf
  * - A socket accepted by an earlier version of the routes at another `path` carries a tag no protocol holds now, and is answered `false`: close it, or serve that `path` again.
  */
 export declare class Sockets extends Sockets_base {
-  /** One dispatcher, with no protocol registered, for the instance whose `State` it is given. */
   static readonly layer: Layer.Layer<Sockets, never, State>;
 }
 /**

package/dist/sockets.mjs

@@ -6,6 +6,7 @@ import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
 import { RpcMessage, RpcSerialization, RpcServer } from "effect/rpc";
 import * as ActionRpc from "@gjermundgaraba/effect-actions/ActionRpc";
 // src/durable/sockets.ts
+const restartCloseCode = 1012;
 const replyToClose = (socket, code, reason) => Effect.sync(() => {
 	if (code >= 1e3 && code !== 1005 && code !== 1006 && code !== 1015) closeQuietly(socket, code, reason);
 	else closeQuietly(socket);
@@ -23,7 +24,6 @@ const replyToClose = (socket, code, reason) => Effect.sync(() => {
 * - A socket accepted by an earlier version of the routes at another `path` carries a tag no protocol holds now, and is answered `false`: close it, or serve that `path` again.
 */
 var Sockets = class Sockets extends Context.Service()("effect-actions-cloudflare/ActionDurableObject/Sockets") {
-	/** One dispatcher, with no protocol registered, for the instance whose `State` it is given. */
 	static layer = Layer.effect(Sockets)(Effect.gen(function* () {
 		const state = yield* State;
 		const receivers = /* @__PURE__ */ new Map();
@@ -54,15 +54,13 @@ const Attachment = Schema.Struct({
 	pending: Schema.optional(Schema.Array(RequestId))
 });
 const decodeAttachment = Schema.decodeUnknownExit(Schema.NullishOr(Attachment));
-/** The socket's attachment, failing when it does not decode, or `undefined` with none. */
 const attachmentOf = (socket) => Exit.map(decodeAttachment(socket.deserializeAttachment()), (held) => held ?? void 0);
-/** The socket's attachment, or `undefined` with none or one that does not decode. */
 const heldOf = (socket) => Exit.match(attachmentOf(socket), {
 	onFailure: Function.constUndefined,
 	onSuccess: (held) => held
 });
 const pendingOf = (socket) => heldOf(socket)?.pending ?? [];
-const tracked = (socket, update) => {
+const heldInAttachment = (socket, update) => {
 	const held = heldOf(socket);
 	if (held === void 0) return true;
 	const pending = update(held.pending ?? []);
@@ -87,7 +85,7 @@ const upgraded = (client) => HttpServerResponse.raw(new Response(null, {
 const closeReasonBytes = 123;
 const bytesOf = (text) => new TextEncoder().encode(text).byteLength;
 const acceptedCode = (code) => Number.isInteger(code) && code >= 4e3 && code <= 4999;
-const refusalOf = (protocol) => Effect.gen(function* () {
+const validatedRefusal = (protocol) => Effect.gen(function* () {
 	if (protocol === void 0) return;
 	const { version, code, reason = `This server speaks protocol ${version}: reload the page` } = protocol;
 	if (!acceptedCode(code)) return yield* Effect.die(/* @__PURE__ */ new Error(`ActionDurableObject.layerWebSocket's protocol.code ${code} is not one it accepts, an integer from 4000 to 4999, the codes a watch ends at: give one of those`));
@@ -119,16 +117,11 @@ const refuseUpgrade = (code, reason) => Effect.suspend(() => {
 	server.close(code, reason);
 	return Effect.succeed(upgraded(client));
 });
-/**
-* A hibernating `RpcServer.Protocol` over the object's WebSockets, speaking JSON, and its
-* upgrade route at `path`. Each socket carries two tags, its group's and its own id's, and keeps
-* its upgrade request's headers in its attachment, so both survive hibernation.
-*/
 const makeProtocol = (state, sockets, { path, protocol: version }) => Effect.gen(function* () {
 	const router = yield* HttpRouter.HttpRouter;
 	const context = yield* Effect.context();
 	const group = groupTag(path);
-	const refusal = yield* refusalOf(version);
+	const refusal = yield* validatedRefusal(version);
 	const idOf = (socket) => socketIdOf(state.getTags(socket));
 	state.setWebSocketAutoResponse(new WebSocketRequestResponsePair(String(parser.encode(RpcMessage.constPing)), String(parser.encode(RpcMessage.constPong))));
 	const disconnects = yield* Queue.make();
@@ -136,7 +129,7 @@ const makeProtocol = (state, sockets, { path, protocol: version }) => Effect.gen
 	const send = (clientId, response) => sendFrame(state, clientId, response).pipe(Effect.andThen(Effect.sync(() => {
 		const settled = settledBy(response);
 		if (settled === void 0) return;
-		for (const socket of state.getWebSockets(socketTag(clientId))) tracked(socket, settled);
+		for (const socket of state.getWebSockets(socketTag(clientId))) heldInAttachment(socket, settled);
 	})), Effect.andThen(subscriptions.sent(clientId, response)));
 	const protocol = yield* RpcServer.Protocol.make((write) => {
 		if (!sockets.register(group, {
@@ -146,7 +139,7 @@ const makeProtocol = (state, sockets, { path, protocol: version }) => Effect.gen
 					const headers = (yield* Effect.orDie(attachmentOf(socket)))?.headers ?? [];
 					const messages = parser.decode(Predicate.isString(data) ? data : new Uint8Array(data));
 					const sent = messages.flatMap((message) => Predicate.isTagged(message, "Request") ? [message.id] : []);
-					const kept = sent.length === 0 || tracked(socket, (pending) => [...pending, ...sent]);
+					const kept = sent.length === 0 || heldInAttachment(socket, (pending) => [...pending, ...sent]);
 					return yield* Effect.forEach(messages, (message) => {
 						if (!Predicate.isTagged(message, "Request")) return write(clientId, message);
 						return kept ? write(clientId, {
@@ -166,7 +159,7 @@ const makeProtocol = (state, sockets, { path, protocol: version }) => Effect.gen
 		})) return Effect.die(/* @__PURE__ */ new Error(`Two ActionDurableObject.layerWebSocket protocols of one object serve the path ${path}: a router prefix does not tell them apart: give each its own path, such as /a/rpc and /b/rpc`));
 		const resumed = subscriptions.resumed(write, (socket, kept) => {
 			if (pendingOf(socket).every(kept)) return true;
-			closeQuietly(socket, 1012, lostCalls);
+			closeQuietly(socket, restartCloseCode, lostCalls);
 			return false;
 		});
 		return Effect.as(resumed, {

package/dist/stub.d.mts

@@ -12,15 +12,15 @@ export interface Stub {
 }
 /**
  * The `RpcClient.Protocol` `RpcClient.make` and `ActionRpc.client` call an object's rpcs with,
- * over `stub`, or over the stub a function returns as each call is sent: each call is one call
+ * over the stub `stubOf` returns as each call is sent: each call is one call
  * of the object's `effectActionsRpc` method, its messages and their answer passed as values,
  * each schema's plain form, which the object serves through `make`'s or `handlers`' `calls`. The stub's own failure is an `RpcClientError`, as an HTTP transport's
  * is, in every call's errors.
  *
  * **Gotchas**
  *
- * - A stub given is held, and many exceptions leave a stub broken, failing every later call through it with the same error: give a function, `() => env.ROOM.getByName(name)`, called as each call is sent, for a new stub each time; one that throws is a defect, not an `RpcClientError`, as it is no failure of the stub.
- * - An `RpcClientError`'s `RpcClientDefect` holds the runtime's error as its `cause`: `.retryable` true allows repeating the call, as Cloudflare's guide says, and `.durableObjectReset` true needs a new stub, which a function gives.
+ * - `stubOf` is called as each call is sent, `() => env.ROOM.getByName(name)`, for a new stub each time, since many exceptions leave a stub broken, failing every later call through it with the same error; one that throws is a defect, not an `RpcClientError`, as it is no failure of the stub.
+ * - An `RpcClientError`'s `RpcClientDefect` holds the runtime's error as its `cause`: `.retryable` true allows repeating the call, as Cloudflare's guide says, and `.durableObjectReset` true needs a new stub, which the next call's `stubOf` gives.
  * - Workers RPC limits a call's arguments and its answer to 32 MiB, serialized: past it, the call fails with the runtime's `limited to 32MiB` error.
  * - An object serving no `calls`, once built, or a class without the method, fails each call, with the object's or the runtime's message as the error's cause; an object whose build fails fails it with that failure first.
  * - A call's interruption does not reach the object, as a stub call cannot be cancelled: its answer is dropped.
@@ -29,7 +29,7 @@ export interface Stub {
  *
  * Guide: `docs/ActionDurableObject-stub.md` in this package.
  */
-export declare const layerStubClient: (stub: Stub | (() => Stub)) => Layer.Layer<RpcClient.Protocol>;
+export declare const layerStubClient: (stubOf: () => Stub) => Layer.Layer<RpcClient.Protocol>;
 type Unary<Rpcs extends Rpc.Any> = Rpcs extends Rpc.Any ? [Rpc.SuccessSchema<Rpcs>] extends [RpcSchema.Stream<infer _A, infer _E>] ? never : Rpcs : never;
 /**
  * A group's rpcs, as `client.<rpc>(payload)`: Effect's native client, each call failing with

package/dist/stub.mjs

@@ -6,6 +6,7 @@ import { RpcClient, RpcClientError, RpcSchema } from "effect/rpc";
 const clientError = (reason) => new RpcClientError.RpcClientError({ reason });
 const isAnswer = Schema.is(Schema.Array(Schema.Struct({ _tag: Schema.String })));
 const completionOf = Schema.decodeUnknownOption(Schema.Union([Schema.TaggedStruct("Exit", { requestId: RequestId }), Schema.Struct({ _tag: Schema.Literals(["Defect", "ClientProtocolError"]) })]));
+const completesCall = (answer, request) => answer.some((response) => Option.exists(completionOf(response), (completion) => !Predicate.isTagged(completion, "Exit") || completion.requestId === request.id));
 const makeProtocol = (target) => RpcClient.Protocol.make((write) => Effect.succeed({
 	send: (clientId, request) => Predicate.isTagged(request, "Request") ? Effect.gen(function* () {
 		const stub = yield* target;
@@ -16,7 +17,7 @@ const makeProtocol = (target) => RpcClient.Protocol.make((write) => Effect.succe
 				cause
 			}))
 		});
-		if (!(isAnswer(answer) && answer.some((response) => Option.exists(completionOf(response), (completion) => !Predicate.isTagged(completion, "Exit") || completion.requestId === request.id)))) return yield* clientError(new RpcClientError.RpcClientDefect({
+		if (!(isAnswer(answer) && completesCall(answer, request))) return yield* clientError(new RpcClientError.RpcClientDefect({
 			message: "The object's answer ended before the call completed: delegate effectActionsRpc to handlers' own, returning its answer",
 			cause: request
 		}));
@@ -28,15 +29,15 @@ const makeProtocol = (target) => RpcClient.Protocol.make((write) => Effect.succe
 }));
 /**
 * The `RpcClient.Protocol` `RpcClient.make` and `ActionRpc.client` call an object's rpcs with,
-* over `stub`, or over the stub a function returns as each call is sent: each call is one call
+* over the stub `stubOf` returns as each call is sent: each call is one call
 * of the object's `effectActionsRpc` method, its messages and their answer passed as values,
 * each schema's plain form, which the object serves through `make`'s or `handlers`' `calls`. The stub's own failure is an `RpcClientError`, as an HTTP transport's
 * is, in every call's errors.
 *
 * **Gotchas**
 *
-* - A stub given is held, and many exceptions leave a stub broken, failing every later call through it with the same error: give a function, `() => env.ROOM.getByName(name)`, called as each call is sent, for a new stub each time; one that throws is a defect, not an `RpcClientError`, as it is no failure of the stub.
-* - An `RpcClientError`'s `RpcClientDefect` holds the runtime's error as its `cause`: `.retryable` true allows repeating the call, as Cloudflare's guide says, and `.durableObjectReset` true needs a new stub, which a function gives.
+* - `stubOf` is called as each call is sent, `() => env.ROOM.getByName(name)`, for a new stub each time, since many exceptions leave a stub broken, failing every later call through it with the same error; one that throws is a defect, not an `RpcClientError`, as it is no failure of the stub.
+* - An `RpcClientError`'s `RpcClientDefect` holds the runtime's error as its `cause`: `.retryable` true allows repeating the call, as Cloudflare's guide says, and `.durableObjectReset` true needs a new stub, which the next call's `stubOf` gives.
 * - Workers RPC limits a call's arguments and its answer to 32 MiB, serialized: past it, the call fails with the runtime's `limited to 32MiB` error.
 * - An object serving no `calls`, once built, or a class without the method, fails each call, with the object's or the runtime's message as the error's cause; an object whose build fails fails it with that failure first.
 * - A call's interruption does not reach the object, as a stub call cannot be cancelled: its answer is dropped.
@@ -45,9 +46,9 @@ const makeProtocol = (target) => RpcClient.Protocol.make((write) => Effect.succe
 *
 * Guide: `docs/ActionDurableObject-stub.md` in this package.
 */
-const layerStubClient = (stub) => Layer.effect(RpcClient.Protocol)(makeProtocol(Predicate.isFunction(stub) ? Effect.sync(stub) : Effect.succeed(stub)));
-const CurrentStub = Context.Reference("effect-actions-cloudflare/ActionDurableObject/CurrentStub", { defaultValue: Function.constUndefined });
-const currentStub = Effect.flatMap(Effect.service(CurrentStub), (stubOf) => stubOf === void 0 ? Effect.die(/* @__PURE__ */ new Error("No stub for the call")) : Effect.sync(stubOf));
+const layerStubClient = (stubOf) => Layer.effect(RpcClient.Protocol)(makeProtocol(Effect.sync(stubOf)));
+const StubOfCurrentCall = Context.Reference("effect-actions-cloudflare/ActionDurableObject/CurrentStub", { defaultValue: Function.constUndefined });
+const currentStub = Effect.flatMap(Effect.service(StubOfCurrentCall), (stubOf) => stubOf === void 0 ? Effect.die(/* @__PURE__ */ new Error("No stub for the call")) : Effect.sync(stubOf));
 /**
 * The rpcs of `group`, as `(stubOf) => client`, for a Worker or an object calling objects of
 * one class: `room(() => env.CHAT_ROOM.getByName(name)).latestAt()`. One native client, built
@@ -70,6 +71,6 @@ const client = (group) => Effect.gen(function* () {
 	const native = yield* RpcClient.make(group).pipe(Effect.provideServiceEffect(RpcClient.Protocol, makeProtocol(currentStub)), Effect.map((made) => made));
 	const rpcs = group.requests.values();
 	const unary = new Set([...rpcs].flatMap((rpc) => RpcSchema.isStreamSchema(rpc.successSchema) ? [] : [rpc._tag]));
-	return (stubOf) => Object.fromEntries(Object.entries(native).flatMap(([tag, method]) => unary.has(tag) ? [[tag, (...args) => method(...args).pipe(Effect.provideService(CurrentStub, stubOf))]] : []));
+	return (stubOf) => Object.fromEntries(Object.entries(native).flatMap(([tag, method]) => unary.has(tag) ? [[tag, (...args) => method(...args).pipe(Effect.provideService(StubOfCurrentCall, stubOf))]] : []));
 });
 export { client, layerStubClient };

package/dist/subscriptions.mjs

@@ -2,7 +2,6 @@ import { deleted } from "./batches.mjs";
 import { RequestId, closeQuietly, groupTag, socketIdOf } from "./frames.mjs";
 import { Effect, Function, Match, Option, Predicate, Schema } from "effect";
 // src/durable/subscriptions.ts
-/** Where an object keeps its sockets' event subscriptions. */
 const keptPrefix = "effect-actions/subscription/";
 const Request = Schema.TaggedStruct("Request", {
 	id: RequestId,
@@ -11,33 +10,27 @@ const Request = Schema.TaggedStruct("Request", {
 });
 const requestOf = Schema.decodeUnknownOption(Request);
 const payloadOf = Schema.decodeUnknownOption(Schema.Json);
+const resumeFailedCode = 1e3;
 const unresumable = "This server could not resume this socket's subscriptions: connect again";
 const suffixOf = (socket, id) => `${socket}#${Predicate.isNumber(id) ? "n" : "s"}${id}`;
 const socketOf = (suffix) => Number(suffix.slice(0, suffix.indexOf("#")));
-/**
-* The event subscriptions of the sockets one `layerWebSocket` path accepted, kept in storage:
-* `keeper` stores each request as `ActionRpc.layer` admits it, `sent` stores the payload that
-* resumes it with each chunk sent and forgets it at its exit, `closed` forgets a socket's, and
-* `resumed` writes each kept one whose socket of this path is still open to the server again,
-* from there.
-*/
 const makeSubscriptions = (state, path) => {
 	const { storage } = state;
 	const group = groupTag(path);
 	const requests = `${keptPrefix}request/${path}#`;
 	const payloads = `${keptPrefix}payload/${path}#`;
 	const keysOf = (suffix) => [`${requests}${suffix}`, `${payloads}${suffix}`];
-	const live = /* @__PURE__ */ new Map();
+	const liveSubscriptionsMirror = /* @__PURE__ */ new Map();
 	const listed = (prefix) => Effect.map(Effect.promise(async () => await storage.list({ prefix })), (found) => [...found].map(([key, value]) => [key.slice(prefix.length), value]));
 	const closed = (socket) => Effect.suspend(() => {
-		const owned = [...live.keys()].filter((suffix) => socketOf(suffix) === socket);
-		for (const suffix of owned) live.delete(suffix);
+		const owned = [...liveSubscriptionsMirror.keys()].filter((suffix) => socketOf(suffix) === socket);
+		for (const suffix of owned) liveSubscriptionsMirror.delete(suffix);
 		return deleted(storage, owned.flatMap(keysOf));
 	});
 	const keeper = { keep: ({ clientId, requestId, tag, payload, headers, resumeFrom }) => Effect.suspend(() => {
 		const suffix = suffixOf(clientId, requestId);
-		const resuming = live.has(suffix);
-		live.set(suffix, resumeFrom);
+		const resuming = liveSubscriptionsMirror.has(suffix);
+		liveSubscriptionsMirror.set(suffix, resumeFrom);
 		if (resuming) return Effect.void;
 		return Effect.promise(async () => {
 			await storage.put({
@@ -51,23 +44,18 @@ const makeSubscriptions = (state, path) => {
 		});
 	}) };
 	const moved = (suffix, values) => Effect.suspend(() => {
-		const payload = live.get(suffix)?.(values);
+		const payload = liveSubscriptionsMirror.get(suffix)?.(values);
 		return payload === void 0 ? Effect.void : Effect.promise(async () => {
 			await storage.put(`${payloads}${suffix}`, payload);
 		});
 	});
 	const sent = (socket, response) => Match.value(response).pipe(Match.tag("Defect", () => closed(socket)), Match.tag("Chunk", ({ requestId, values }) => moved(suffixOf(socket, requestId), values)), Match.tag("Exit", ({ requestId }) => Effect.suspend(() => {
 		const suffix = suffixOf(socket, requestId);
-		return live.delete(suffix) ? Effect.promise(async () => await storage.delete(keysOf(suffix))) : Effect.void;
+		return liveSubscriptionsMirror.delete(suffix) ? Effect.promise(async () => await storage.delete(keysOf(suffix))) : Effect.void;
 	})), Match.orElse(() => Effect.void));
 	const unresumed = (socket) => Effect.andThen(Effect.logWarning(`layerWebSocket at ${path} could not resume a socket's kept event subscriptions, and closes it`), Effect.sync(() => {
-		closeQuietly(socket, 1e3, unresumable);
+		closeQuietly(socket, resumeFailedCode, unresumable);
 	}));
-	/**
-	* Writes each kept subscription of a socket of this path still open to the server, from where
-	* it reached, and forgets the rest: `held` answers whether a socket stays open, given whether
-	* one of its requests is a subscription kept for it, and closes one that does not.
-	*/
 	const resumed = (write, held) => Effect.gen(function* () {
 		const kept = yield* listed(requests);
 		const resumeFrom = new Map(yield* listed(payloads));
@@ -88,7 +76,7 @@ const makeSubscriptions = (state, path) => {
 		const unread = new Set(entries.flatMap(({ socket, request }) => open.has(socket) && Option.isNone(request) ? [socket] : []));
 		const gone = [...resumeFrom.keys()].flatMap((suffix) => keptIds.has(suffix) ? [] : [`${payloads}${suffix}`]);
 		for (const { suffix, socket, request } of entries) if (open.has(socket) && !unread.has(socket) && Option.isSome(request)) {
-			live.set(suffix, Function.constUndefined);
+			liveSubscriptionsMirror.set(suffix, Function.constUndefined);
 			yield* write(socket, request.value);
 		} else gone.push(...keysOf(suffix));
 		yield* deleted(storage, gone);

package/dist/tasks.mjs

@@ -1,6 +1,5 @@
 import { Clock, Context, Effect } from "effect";
 // src/durable/tasks.ts
-/** The alarm owner a task's time is kept under, one per task name. */
 const taskOwner = (name) => `task:${name}`;
 /**
 * Runs the object's tasks, `make`'s or `handlers`' `tasks`, by name, after a change, on the
@@ -15,16 +14,12 @@ const taskOwner = (name) => `task:${name}`;
 * - A run that fails is logged and retried as the alarm retries an owner: 2 seconds later, doubling, six times, then hourly.
 */
 var Tasks = class extends Context.Service()("effect-actions-cloudflare/ActionDurableObject/Tasks") {};
-/**
-* The instance's `Tasks` over its `schedule`, and the alarm owners that run each of `tasks`, by
-* the name `runAfter` takes.
-*/
 const makeTasks = (schedule, tasks) => ({
 	tasks: Tasks.of({ runAfter: (name, change) => Effect.gen(function* () {
 		if (!Object.hasOwn(tasks, name)) return yield* Effect.die(/* @__PURE__ */ new Error(`ActionDurableObject.Tasks: this object has no task ${name} (give make or handlers a tasks entry named ${name})`));
-		const marked = schedule.set(taskOwner(name), yield* Clock.currentTimeMillis);
-		yield* marked;
-		return yield* Effect.ensuring(change, marked);
+		const markDueNow = schedule.set(taskOwner(name), yield* Clock.currentTimeMillis);
+		yield* markDueNow;
+		return yield* Effect.ensuring(change, markDueNow);
 	}) }),
 	owners: Object.fromEntries(Object.entries(tasks).map(([name, task]) => [taskOwner(name), () => task]))
 });