@deslop/scope 0.1.1100 → 0.1.1102

package/dist/server.js

@@ -3728,6 +3728,38 @@ const isLessThanOrEqualTo$1 = (O) => dual(2, (self, that) => O(self, that) !== 1
 */
 const isGreaterThanOrEqualTo$2 = (O) => dual(2, (self, that) => O(self, that) !== -1);
 /**
+* Returns the minimum of two values according to the given order. If they are equal, returns the first argument.
+*
+* **When to use**
+*
+* Use when you need to select the smaller of two values according to an
+* `Order`.
+*
+* **Details**
+*
+* Returns the value that compares as less than or equal to the other value. If
+* values are equal, the first argument is returned.
+*
+* **Example** (Selecting the minimum value)
+*
+* ```ts import.meta.vitest
+* import { Order } from "effect"
+*
+* const minNumber = Order.min(Order.Number)
+*
+* minNumber(1, 2) // => 1
+* minNumber(2, 1) // => 1
+* minNumber(1, 1) // => 1
+* ```
+*
+* @see {@link max} for the maximum of two values
+* @see {@link clamp} to clamp a value between min and max
+* @stability stable
+* @category comparisons
+* @since 2.0.0
+*/
+const min$1 = (O) => dual(2, (self, that) => self === that || O(self, that) < 1 ? self : that);
+/**
 * Returns the maximum of two values according to the given order. If they are equal, returns the first argument.
 *
 * **When to use**
@@ -7330,7 +7362,7 @@ const some = /*#__PURE__*/ dual(2, (self, predicate) => self.some(predicate));
 * @category constructors
 * @since 2.0.0
 */
-const unfold = (b, f) => {
+const unfold$1 = (b, f) => {
 	const out = [];
 	let next = b;
 	while (true) {
@@ -13908,6 +13940,51 @@ const formatIso$1 = (self) => toDateUtc$1(self).toISOString();
 */
 const Number$4 = globalThis.Number;
 /**
+* Order instance for `number` values.
+*
+* **When to use**
+*
+* Use when you need to sort or compare numbers through APIs that accept an
+* ordering instance.
+*
+* **Example** (Comparing numbers)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.Order(1, 2) // => -1
+* Number.Order(2, 1) // => 1
+* Number.Order(1, 1) // => 0
+* ```
+*
+* @stability stable
+* @category instances
+* @since 2.0.0
+*/
+const Order$2 = Number$5;
+/**
+* Returns the minimum between two `number`s.
+*
+* **When to use**
+*
+* Use to select the smaller of two numbers.
+*
+* **Example** (Finding the minimum)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.min(2, 3) // => 2
+* ```
+*
+* @see {@link max} for selecting the larger value
+*
+* @stability stable
+* @category math
+* @since 2.0.0
+*/
+const min = /*#__PURE__*/ min$1(Order$2);
+/**
 * Returns the maximum between two `number`s.
 *
 * **When to use**
@@ -13928,7 +14005,31 @@ const Number$4 = globalThis.Number;
 * @category math
 * @since 2.0.0
 */
-const max = /*#__PURE__*/ max$1(Number$5);
+const max = /*#__PURE__*/ max$1(Order$2);
+/**
+* Returns the next power of 2 from the given number.
+*
+* **When to use**
+*
+* Use to round a number up to the next power of two.
+*
+* **Example** (Finding the next power of two)
+*
+* ```ts import.meta.vitest
+* import { Number } from "effect"
+*
+* Number.nextPow2(5) // => 8
+* Number.nextPow2(17) // => 32
+* ```
+*
+* @stability stable
+* @category math
+* @since 2.0.0
+*/
+const nextPow2 = (n) => {
+	const nextPow = Math.ceil(Math.log(n) / Math.log(2));
+	return Math.max(Math.pow(2, nextPow), 2);
+};
 /**
 * Parses a `number` from a `string` safely using the `Number()` function.
 * The following special string values are supported: "NaN", "Infinity", "-Infinity".
@@ -21199,6 +21300,19 @@ const filter = (self, f) => {
 const remove$2 = (self, value) => filter(self, (v) => v !== value);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/PubSub.js
+/**
+* Broadcasts values from publishers to many subscribers.
+*
+* Publishers add messages with `publish` or `publishAll`, and each active
+* `Subscription` receives its own copy of every accepted message. Unlike a
+* queue, subscribers do not compete for messages. This module includes bounded,
+* dropping, sliding, and unbounded hubs, optional replay buffers for late
+* subscribers, message-taking helpers, capacity and shutdown operations, a
+* type guard, and low-level types for custom hub strategies.
+*
+* @stability stable
+* @since 2.0.0
+*/
 const TypeId$47 = "~effect/PubSub";
 const SubscriptionTypeId = "~effect/PubSub/Subscription";
 /**
@@ -21232,6 +21346,48 @@ const SubscriptionTypeId = "~effect/PubSub/Subscription";
 */
 const make$62 = (options) => sync(() => makePubSubUnsafe(options.atomicPubSub(), /* @__PURE__ */ new Map(), makeUnsafe$6(), makeUnsafe$4(false), make$64(false), options.strategy(), make$64(none())));
 /**
+* Creates a bounded `PubSub` with the sliding strategy. The `PubSub` will add new
+* messages and drop old messages if the `PubSub` is at capacity.
+*
+* **Details**
+*
+* The capacity must be a positive integer or `Infinity` for unbounded storage.
+* Invalid capacities cause the effect to die.
+* For best performance use capacities that are powers of two.
+*
+* **Example** (Sliding old messages when full)
+*
+* ```ts import.meta.vitest
+* import { Effect, PubSub } from "effect"
+*
+* const program = Effect.scoped(Effect.gen(function*() {
+*   // Create sliding PubSub that evicts old messages when full
+*   const pubsub = yield* PubSub.sliding<string>(3)
+*
+*   const subscription = yield* PubSub.subscribe(pubsub)
+*
+*   // Fill and overflow the PubSub
+*   yield* PubSub.publish(pubsub, "msg1")
+*   yield* PubSub.publish(pubsub, "msg2")
+*   yield* PubSub.publish(pubsub, "msg3")
+*   yield* PubSub.publish(pubsub, "msg4") // "msg1" is evicted
+*
+*   return yield* PubSub.takeAll(subscription)
+* }))
+*
+* const actual = await Effect.runPromise(program)
+* actual // => ["msg2", "msg3", "msg4"]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const sliding = (capacity) => make$62({
+	atomicPubSub: () => makeAtomicBounded(capacity),
+	strategy: () => new SlidingStrategy()
+});
+/**
 * Creates an unbounded `PubSub`.
 *
 * **Example** (Creating an unbounded PubSub)
@@ -21266,6 +21422,45 @@ const unbounded = (options) => make$62({
 	strategy: () => new DroppingStrategy()
 });
 /**
+* Creates a bounded atomic PubSub implementation with optional replay buffer.
+*
+* **When to use**
+*
+* Use to provide bounded message storage when building a custom `PubSub` with
+* `make` and an explicit delivery strategy.
+*
+* **Details**
+*
+* Pass either a capacity number or an options object with `capacity` and
+* optional `replay`. A positive `replay` value enables a replay buffer for late
+* subscribers, and fractional replay sizes are rounded up.
+*
+* **Gotchas**
+*
+* The capacity must be a positive integer or `Infinity` for unbounded storage;
+* invalid capacities throw synchronously before an atomic implementation is
+* created.
+*
+* @see {@link make} for constructing a `PubSub` from an atomic implementation and delivery strategy
+* @see {@link makeAtomicUnbounded} for an atomic implementation without a bounded capacity
+* @see {@link bounded} for the higher-level backpressure constructor
+* @see {@link dropping} for the higher-level dropping constructor
+* @see {@link sliding} for the higher-level sliding constructor
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const makeAtomicBounded = (capacity) => {
+	const options = typeof capacity === "number" ? { capacity } : capacity;
+	ensureCapacity(options.capacity);
+	if (options.capacity === Infinity) return makeAtomicUnbounded(options);
+	const replayBuffer = options.replay && options.replay > 0 ? new ReplayBuffer(Math.ceil(options.replay)) : void 0;
+	if (options.capacity === 1) return new BoundedPubSubSingle(replayBuffer);
+	else if (nextPow2(options.capacity) === options.capacity) return new BoundedPubSubPow2(options.capacity, replayBuffer);
+	else return new BoundedPubSubArb(options.capacity, replayBuffer);
+};
+/**
 * Creates an unbounded atomic PubSub implementation with optional replay buffer.
 *
 * **When to use**
@@ -21491,6 +21686,406 @@ const removeSubscribers = (subscribers, subscription, pollers) => {
 	if (set.size === 0) subscribers.delete(subscription);
 };
 const makeSubscriptionUnsafe = (pubsub, subscribers, strategy, ended) => new SubscriptionImpl(pubsub, subscribers, pubsub.subscribe(), make$63(), makeUnsafe$4(false), make$64(false), strategy, pubsub.replayWindow(), ended);
+var BoundedPubSubArb = class {
+	array;
+	replayIndices;
+	publisherIndex = 0;
+	subscribers;
+	subscriberCount = 0;
+	subscribersIndex = 0;
+	capacity;
+	replayBuffer;
+	constructor(capacity, replayBuffer) {
+		this.capacity = capacity;
+		this.replayBuffer = replayBuffer;
+		this.array = Array.from({ length: capacity });
+		this.replayIndices = replayBuffer ? Array.from({ length: capacity }) : [];
+		this.subscribers = Array.from({ length: capacity });
+	}
+	replayWindow() {
+		return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+	}
+	isEmpty() {
+		return this.publisherIndex === this.subscribersIndex;
+	}
+	isFull() {
+		return this.publisherIndex === this.subscribersIndex + this.capacity;
+	}
+	size() {
+		return this.publisherIndex - this.subscribersIndex;
+	}
+	publish(value) {
+		if (this.isFull()) return false;
+		const replayIndex = this.replayBuffer?.offer(value);
+		if (this.subscriberCount !== 0) {
+			const index = this.publisherIndex % this.capacity;
+			this.array[index] = value;
+			if (replayIndex !== void 0) this.replayIndices[index] = replayIndex;
+			this.subscribers[index] = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return true;
+	}
+	publishAll(elements) {
+		if (this.subscriberCount === 0) {
+			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
+			return [];
+		}
+		const chunk = fromIterable$5(elements);
+		const n = chunk.length;
+		const size = this.publisherIndex - this.subscribersIndex;
+		const available = this.capacity - size;
+		const forPubSub = Math.min(n, available);
+		if (forPubSub === 0) return chunk;
+		let iteratorIndex = 0;
+		const publishAllIndex = this.publisherIndex + forPubSub;
+		while (this.publisherIndex !== publishAllIndex) {
+			const a = chunk[iteratorIndex++];
+			const index = this.publisherIndex % this.capacity;
+			this.array[index] = a;
+			const replayIndex = this.replayBuffer?.offer(a);
+			if (replayIndex !== void 0) this.replayIndices[index] = replayIndex;
+			this.subscribers[index] = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return chunk.slice(iteratorIndex);
+	}
+	slide() {
+		if (this.subscribersIndex !== this.publisherIndex) {
+			const index = this.subscribersIndex % this.capacity;
+			const value = this.array[index];
+			this.array[index] = AbsentValue;
+			this.subscribers[index] = 0;
+			this.subscribersIndex += 1;
+			this.replayBuffer?.slide(value, this.replayIndices[index]);
+		}
+	}
+	subscribe() {
+		this.subscriberCount += 1;
+		return new BoundedPubSubArbSubscription(this, this.publisherIndex, false);
+	}
+};
+var BoundedPubSubArbSubscription = class {
+	self;
+	subscriberIndex;
+	unsubscribed;
+	constructor(self, subscriberIndex, unsubscribed) {
+		this.self = self;
+		this.subscriberIndex = subscriberIndex;
+		this.unsubscribed = unsubscribed;
+	}
+	isEmpty() {
+		return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
+	}
+	size() {
+		if (this.unsubscribed) return 0;
+		return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+	}
+	poll() {
+		if (this.unsubscribed) return Empty$2;
+		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+		if (this.subscriberIndex !== this.self.publisherIndex) {
+			const index = this.subscriberIndex % this.self.capacity;
+			const elem = this.self.array[index];
+			this.self.subscribers[index] -= 1;
+			if (this.self.subscribers[index] === 0) {
+				this.self.array[index] = AbsentValue;
+				this.self.subscribersIndex += 1;
+			}
+			this.subscriberIndex += 1;
+			return elem;
+		}
+		return Empty$2;
+	}
+	pollUpTo(n) {
+		n = normalize$1(n);
+		if (this.unsubscribed) return [];
+		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+		const size = this.self.publisherIndex - this.subscriberIndex;
+		const toPoll = Math.min(n, size);
+		if (toPoll <= 0) return [];
+		const builder = [];
+		const pollUpToIndex = this.subscriberIndex + toPoll;
+		while (this.subscriberIndex !== pollUpToIndex) {
+			const index = this.subscriberIndex % this.self.capacity;
+			const a = this.self.array[index];
+			this.self.subscribers[index] -= 1;
+			if (this.self.subscribers[index] === 0) {
+				this.self.array[index] = AbsentValue;
+				this.self.subscribersIndex += 1;
+			}
+			builder.push(a);
+			this.subscriberIndex += 1;
+		}
+		return builder;
+	}
+	unsubscribe() {
+		if (!this.unsubscribed) {
+			this.unsubscribed = true;
+			this.self.subscriberCount -= 1;
+			this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+			while (this.subscriberIndex !== this.self.publisherIndex) {
+				const index = this.subscriberIndex % this.self.capacity;
+				this.self.subscribers[index] -= 1;
+				if (this.self.subscribers[index] === 0) {
+					this.self.array[index] = AbsentValue;
+					this.self.subscribersIndex += 1;
+				}
+				this.subscriberIndex += 1;
+			}
+		}
+	}
+};
+var BoundedPubSubPow2 = class {
+	array;
+	replayIndices;
+	mask;
+	publisherIndex = 0;
+	subscribers;
+	subscriberCount = 0;
+	subscribersIndex = 0;
+	capacity;
+	replayBuffer;
+	constructor(capacity, replayBuffer) {
+		this.capacity = capacity;
+		this.replayBuffer = replayBuffer;
+		this.array = Array.from({ length: capacity });
+		this.replayIndices = replayBuffer ? Array.from({ length: capacity }) : [];
+		this.mask = capacity - 1;
+		this.subscribers = Array.from({ length: capacity });
+	}
+	replayWindow() {
+		return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+	}
+	isEmpty() {
+		return this.publisherIndex === this.subscribersIndex;
+	}
+	isFull() {
+		return this.publisherIndex === this.subscribersIndex + this.capacity;
+	}
+	size() {
+		return this.publisherIndex - this.subscribersIndex;
+	}
+	publish(value) {
+		if (this.isFull()) return false;
+		const replayIndex = this.replayBuffer?.offer(value);
+		if (this.subscriberCount !== 0) {
+			const index = this.publisherIndex & this.mask;
+			this.array[index] = value;
+			if (replayIndex !== void 0) this.replayIndices[index] = replayIndex;
+			this.subscribers[index] = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return true;
+	}
+	publishAll(elements) {
+		if (this.subscriberCount === 0) {
+			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
+			return [];
+		}
+		const chunk = fromIterable$5(elements);
+		const n = chunk.length;
+		const size = this.publisherIndex - this.subscribersIndex;
+		const available = this.capacity - size;
+		const forPubSub = Math.min(n, available);
+		if (forPubSub === 0) return chunk;
+		let iteratorIndex = 0;
+		const publishAllIndex = this.publisherIndex + forPubSub;
+		while (this.publisherIndex !== publishAllIndex) {
+			const elem = chunk[iteratorIndex++];
+			const index = this.publisherIndex & this.mask;
+			this.array[index] = elem;
+			const replayIndex = this.replayBuffer?.offer(elem);
+			if (replayIndex !== void 0) this.replayIndices[index] = replayIndex;
+			this.subscribers[index] = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return chunk.slice(iteratorIndex);
+	}
+	slide() {
+		if (this.subscribersIndex !== this.publisherIndex) {
+			const index = this.subscribersIndex & this.mask;
+			const value = this.array[index];
+			this.array[index] = AbsentValue;
+			this.subscribers[index] = 0;
+			this.subscribersIndex += 1;
+			this.replayBuffer?.slide(value, this.replayIndices[index]);
+		}
+	}
+	subscribe() {
+		this.subscriberCount += 1;
+		return new BoundedPubSubPow2Subscription(this, this.publisherIndex, false);
+	}
+};
+var BoundedPubSubPow2Subscription = class {
+	self;
+	subscriberIndex;
+	unsubscribed;
+	constructor(self, subscriberIndex, unsubscribed) {
+		this.self = self;
+		this.subscriberIndex = subscriberIndex;
+		this.unsubscribed = unsubscribed;
+	}
+	isEmpty() {
+		return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
+	}
+	size() {
+		if (this.unsubscribed) return 0;
+		return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+	}
+	poll() {
+		if (this.unsubscribed) return Empty$2;
+		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+		if (this.subscriberIndex !== this.self.publisherIndex) {
+			const index = this.subscriberIndex & this.self.mask;
+			const elem = this.self.array[index];
+			this.self.subscribers[index] -= 1;
+			if (this.self.subscribers[index] === 0) {
+				this.self.array[index] = AbsentValue;
+				this.self.subscribersIndex += 1;
+			}
+			this.subscriberIndex += 1;
+			return elem;
+		}
+		return Empty$2;
+	}
+	pollUpTo(n) {
+		n = normalize$1(n);
+		if (this.unsubscribed) return [];
+		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+		const size = this.self.publisherIndex - this.subscriberIndex;
+		const toPoll = Math.min(n, size);
+		if (toPoll <= 0) return [];
+		const builder = [];
+		const pollUpToIndex = this.subscriberIndex + toPoll;
+		while (this.subscriberIndex !== pollUpToIndex) {
+			const index = this.subscriberIndex & this.self.mask;
+			const elem = this.self.array[index];
+			this.self.subscribers[index] -= 1;
+			if (this.self.subscribers[index] === 0) {
+				this.self.array[index] = AbsentValue;
+				this.self.subscribersIndex += 1;
+			}
+			builder.push(elem);
+			this.subscriberIndex += 1;
+		}
+		return builder;
+	}
+	unsubscribe() {
+		if (!this.unsubscribed) {
+			this.unsubscribed = true;
+			this.self.subscriberCount -= 1;
+			this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+			while (this.subscriberIndex !== this.self.publisherIndex) {
+				const index = this.subscriberIndex & this.self.mask;
+				this.self.subscribers[index] -= 1;
+				if (this.self.subscribers[index] === 0) {
+					this.self.array[index] = AbsentValue;
+					this.self.subscribersIndex += 1;
+				}
+				this.subscriberIndex += 1;
+			}
+		}
+	}
+};
+var BoundedPubSubSingle = class {
+	publisherIndex = 0;
+	subscriberCount = 0;
+	subscribers = 0;
+	value = AbsentValue;
+	replayIndex = 0;
+	capacity = 1;
+	replayBuffer;
+	constructor(replayBuffer) {
+		this.replayBuffer = replayBuffer;
+	}
+	replayWindow() {
+		return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	isEmpty() {
+		return this.subscribers === 0;
+	}
+	isFull() {
+		return !this.isEmpty();
+	}
+	size() {
+		return this.isEmpty() ? 0 : 1;
+	}
+	publish(value) {
+		if (this.isFull()) return false;
+		const replayIndex = this.replayBuffer?.offer(value);
+		if (this.subscriberCount !== 0) {
+			this.value = value;
+			if (replayIndex !== void 0) this.replayIndex = replayIndex;
+			this.subscribers = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return true;
+	}
+	publishAll(elements) {
+		if (this.subscriberCount === 0) {
+			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
+			return [];
+		}
+		const chunk = fromIterable$5(elements);
+		if (chunk.length === 0) return chunk;
+		if (this.publish(chunk[0])) return chunk.slice(1);
+		else return chunk;
+	}
+	slide() {
+		if (this.isFull()) {
+			const value = this.value;
+			this.subscribers = 0;
+			this.value = AbsentValue;
+			this.replayBuffer?.slide(value, this.replayIndex);
+		}
+	}
+	subscribe() {
+		this.subscriberCount += 1;
+		return new BoundedPubSubSingleSubscription(this, this.publisherIndex, false);
+	}
+};
+var BoundedPubSubSingleSubscription = class {
+	self;
+	subscriberIndex;
+	unsubscribed;
+	constructor(self, subscriberIndex, unsubscribed) {
+		this.self = self;
+		this.subscriberIndex = subscriberIndex;
+		this.unsubscribed = unsubscribed;
+	}
+	isEmpty() {
+		return this.unsubscribed || this.self.subscribers === 0 || this.subscriberIndex === this.self.publisherIndex;
+	}
+	size() {
+		return this.isEmpty() ? 0 : 1;
+	}
+	poll() {
+		if (this.isEmpty()) return Empty$2;
+		const elem = this.self.value;
+		this.self.subscribers -= 1;
+		if (this.self.subscribers === 0) this.self.value = AbsentValue;
+		this.subscriberIndex = this.self.publisherIndex;
+		return elem;
+	}
+	pollUpTo(n) {
+		if (normalize$1(n) < 1 || this.isEmpty()) return [];
+		return [this.poll()];
+	}
+	unsubscribe() {
+		if (!this.unsubscribed) {
+			this.unsubscribed = true;
+			this.self.subscriberCount -= 1;
+			if (this.self.subscribers !== 0 && this.subscriberIndex !== this.self.publisherIndex) {
+				this.self.subscribers -= 1;
+				if (this.self.subscribers === 0) this.self.value = AbsentValue;
+			}
+		}
+	}
+};
 var UnboundedPubSub = class {
 	publisherHead = {
 		value: AbsentValue,
@@ -21686,6 +22281,9 @@ var PubSubImpl = class {
 	}
 };
 const makePubSubUnsafe = (pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy, ended) => new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy, ended);
+const ensureCapacity = (capacity) => {
+	if (capacity <= 0 || capacity !== Infinity && !Number.isInteger(capacity)) throw new Error(`Cannot construct PubSub with capacity of ${capacity}`);
+};
 /**
 * Represents the dropping strategy for bounded `PubSub` values.
 *
@@ -21750,6 +22348,89 @@ var DroppingStrategy = class {
 		return strategyCompleteSubscribersUnsafe(this, pubsub, subscribers);
 	}
 };
+/**
+* Represents the sliding strategy for bounded `PubSub` values.
+*
+* **When to use**
+*
+* Use to keep the most recent messages when the `PubSub` is at capacity.
+*
+* **Details**
+*
+* New messages are accepted by evicting older messages from the bounded
+* `PubSub`.
+*
+* **Gotchas**
+*
+* Slow subscribers may miss older messages that are evicted before they are
+* consumed.
+*
+* **Example** (Applying a sliding strategy)
+*
+* ```ts import.meta.vitest
+* import { Effect, PubSub } from "effect"
+*
+* const program = Effect.scoped(Effect.gen(function*() {
+*   // Explicitly create a PubSub with a sliding strategy
+*   const pubsub = yield* PubSub.make<string>({
+*     atomicPubSub: () => PubSub.makeAtomicBounded(2),
+*     strategy: () => new PubSub.SlidingStrategy()
+*   })
+*
+*   const subscription = yield* PubSub.subscribe(pubsub)
+*
+*   // Publish messages that exceed capacity
+*   yield* PubSub.publish(pubsub, "msg1") // stored
+*   yield* PubSub.publish(pubsub, "msg2") // stored
+*   yield* PubSub.publish(pubsub, "msg3") // "msg1" evicted, "msg3" stored
+*   yield* PubSub.publish(pubsub, "msg4") // "msg2" evicted, "msg4" stored
+*
+*   // Subscribers will see the most recent messages
+*   return yield* PubSub.takeAll(subscription)
+* }))
+*
+* const actual = await Effect.runPromise(program)
+* actual // => ["msg3", "msg4"]
+* ```
+*
+* @stability stable
+* @category models
+* @since 4.0.0
+*/
+var SlidingStrategy = class {
+	get shutdown() {
+		return void_$1;
+	}
+	handleSurplus(pubsub, subscribers, elements, _isShutdown, ended) {
+		return sync(() => {
+			if (isSome(ended.current)) return false;
+			this.slidingPublishUnsafe(pubsub, elements);
+			this.completeSubscribersUnsafe(pubsub, subscribers);
+			return true;
+		});
+	}
+	onPubSubEmptySpaceUnsafe(_pubsub, _subscribers) {}
+	completePollersUnsafe(pubsub, subscribers, subscription, pollers) {
+		return strategyCompletePollersUnsafe(this, pubsub, subscribers, subscription, pollers);
+	}
+	completeSubscribersUnsafe(pubsub, subscribers) {
+		return strategyCompleteSubscribersUnsafe(this, pubsub, subscribers);
+	}
+	slidingPublishUnsafe(pubsub, elements) {
+		const it = elements[Symbol.iterator]();
+		let next = it.next();
+		if (!next.done && pubsub.capacity > 0) {
+			let a = next.value;
+			let loop = true;
+			while (loop) {
+				pubsub.slide();
+				const pub = pubsub.publish(a);
+				if (pub && (next = it.next()) && !next.done) a = next.value;
+				else if (pub) loop = false;
+			}
+		}
+	}
+};
 const strategyCompletePollersUnsafe = (strategy, pubsub, subscribers, subscription, pollers) => {
 	let keepPolling = true;
 	while (keepPolling && !subscription.isEmpty()) {
@@ -25554,6 +26235,41 @@ const fromQueue = (queue) => fromChannel(fromQueueArray(queue));
 */
 const fromReadableStream = (options) => fromChannel(fromReadableStream$1(options));
 /**
+* Creates a stream by repeatedly applying an effectful step function to a
+* state.
+*
+* **Details**
+*
+* Each `readonly [value, nextState]` result emits `value` and continues with
+* `nextState`; returning `undefined` ends the stream.
+*
+* **Example** (Unfolding stream state)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const stream = Stream.unfold(1, (n) => Effect.succeed([n, n + 1] as const))
+*   const values = yield* Stream.runCollect(stream.pipe(Stream.take(5)))
+*   values // => [ 1, 2, 3, 4, 5 ]
+* })
+*
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const unfold = (s, f) => fromPull(sync(() => {
+	let state = s;
+	return flatMap$1(suspend$2(() => f(state)), (next) => {
+		if (next === void 0) return done();
+		state = next[1];
+		return succeed$4(of(next[0]));
+	});
+}));
+/**
 * Creates a stream produced from an `Effect`.
 *
 * **Example** (Unwrapping a stream effect)
@@ -25753,6 +26469,53 @@ const mapError = /*#__PURE__*/ dual(2, (self, f) => fromChannel(mapError$1(self.
 */
 const orDie = (self) => fromChannel(orDie$1(self.channel));
 /**
+* Takes elements until the predicate matches.
+*
+* **Details**
+*
+* When `excludeLast` is `true`, the matching element is dropped.
+*
+* **Example** (Taking until a predicate matches)
+*
+* ```ts import.meta.vitest
+* import { Effect, Stream } from "effect"
+*
+* const stream = Stream.range(1, 5)
+*
+* const program = Effect.gen(function*() {
+*   const inclusive = yield* stream.pipe(
+*     Stream.takeUntil((n) => n % 3 === 0),
+*     Stream.runCollect
+*   )
+*   inclusive // => [ 1, 2, 3 ]
+*
+*   const exclusive = yield* stream.pipe(
+*     Stream.takeUntil((n) => n % 3 === 0, { excludeLast: true }),
+*     Stream.runCollect
+*   )
+*   exclusive // => [ 1, 2 ]
+* })
+* await Effect.runPromise(program)
+* ```
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const takeUntil = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, predicate, options) => transformPull(self, (pull, _scope) => sync(() => {
+	let i = 0;
+	let done$8 = false;
+	return flatMap$1(suspend$2(() => done$8 ? done() : pull), (chunk) => {
+		const index = chunk.findIndex((a) => predicate(a, i++));
+		if (index >= 0) {
+			done$8 = true;
+			const arr = chunk.slice(0, options?.excludeLast ? index : index + 1);
+			return isReadonlyArrayNonEmpty(arr) ? succeed$4(arr) : done();
+		}
+		return succeed$4(chunk);
+	});
+})));
+/**
 * Drops the first `n` elements from this stream.
 *
 * **Details**
@@ -35886,6 +36649,35 @@ function toRepresentations(asts, options) {
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.5/node_modules/effect/dist/Struct.js
 /**
+* Creates a new struct containing only the specified keys.
+*
+* **When to use**
+*
+* Use to narrow a struct down to a subset of its properties.
+*
+* **Gotchas**
+*
+* Keys not present in the struct are silently ignored.
+*
+* **Example** (Selecting specific properties)
+*
+* ```ts import.meta.vitest
+* import { pipe, Struct } from "effect"
+*
+* const user = { name: "Alice", age: 30, admin: true }
+* pipe(user, Struct.pick(["name", "age"])) // => { name: "Alice", age: 30 }
+* ```
+*
+* @see {@link omit} – the inverse (exclude keys instead)
+* @see {@link get} – extract a single value
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const pick = /*#__PURE__*/ dual(2, (self, keys) => {
+	return buildStruct(self, (k, v) => hasPropertyKey(keys, k) ? [k, v] : void 0);
+});
+/**
 * Creates a new struct with the specified keys removed.
 *
 * **When to use**
@@ -66247,17 +67039,31 @@ const Resource$1 = Literals([
 	"https://portfolio.mp281x.xyz/mcp",
 	"https://otel.mp281x.xyz"
 ]);
-const Authorization = Struct({
+const authorizationFields = {
 	challenge: NonEmptyString,
 	clientId: NonEmptyString,
 	redirectUri: NonEmptyString,
 	resources: ArraySchema(Resource$1),
 	state: NonEmptyString
-});
+};
 const Registration = Struct({
+	client_name: optionalKey(String$2.check(isMaxLength(100))),
 	redirect_uris: NonEmptyArray(NonEmptyString),
 	token_endpoint_auth_method: optionalKey(Literal("none"))
 });
+const PendingAuthorization = Struct({
+	clientName: String$2,
+	createdAt: Finite,
+	expiresAt: Finite,
+	id: NonEmptyString,
+	redirectUri: NonEmptyString,
+	resources: ArraySchema(Resource$1)
+});
+const AuthorizationStatus = TaggedUnion({
+	Completed: { url: NonEmptyString },
+	Expired: {},
+	Waiting: { request: PendingAuthorization }
+});
 const AuthorizeParams = Struct({
 	client_id: NonEmptyString,
 	code_challenge: NonEmptyString,
@@ -66287,11 +67093,18 @@ const Stored = TaggedUnion({
 		resources: ArraySchema(Resource$1),
 		user: User
 	},
-	Client: { redirects: NonEmptyArray(NonEmptyString) },
+	Client: {
+		name: optionalKey(String$2),
+		redirects: NonEmptyArray(NonEmptyString)
+	},
 	Code: {
-		...Authorization.fields,
+		...authorizationFields,
 		user: User
 	},
+	Delivered: {
+		id: NonEmptyString,
+		url: NonEmptyString
+	},
 	Login: {
 		request: optionalKey(NonEmptyString),
 		verifier: NonEmptyString
@@ -66302,7 +67115,17 @@ const Stored = TaggedUnion({
 		resources: ArraySchema(Resource$1),
 		user: User
 	},
-	Request: Authorization.fields,
+	Request: {
+		...authorizationFields,
+		clientName: String$2,
+		createdAt: Finite,
+		decision: TaggedUnion({
+			Approved: { user: User },
+			Denied: {},
+			Pending: {}
+		}),
+		id: NonEmptyString
+	},
 	Session: { user: User },
 	UsedRefresh: {
 		clientId: NonEmptyString,
@@ -66310,6 +67133,11 @@ const Stored = TaggedUnion({
 	}
 });
 const StoredRow = Struct({ payload: String$2 });
+const AuthorizationRow = Struct({
+	expiresAt: Finite,
+	hash: String$2,
+	payload: String$2
+});
 const RequestParams = Struct({ request: NonEmptyString });
 const SignInParams = Struct({ request: optionalKey(NonEmptyString) });
 const ConsentParams = Struct({
@@ -66341,7 +67169,6 @@ Struct({
 	expires_in: Finite,
 	refresh_token: NonEmptyString
 });
-Struct({ url: NonEmptyString });
 const VerificationParams = Struct({ resource: Resource$1 });
 //#endregion
 //#region ../../packages/auth/src/lib/utils.ts
@@ -66359,7 +67186,7 @@ var RpcAuth = class RpcAuth extends Service$1()("@deslop/auth/lib/utils/RpcAuth"
 //#region ../../packages/auth/src/service.ts
 const SESSION_COOKIE = "__Secure-session";
 const LOGIN_COOKIE = "__Host-login";
-const REQUEST_COOKIE = "__Host-request";
+const REQUEST_COOKIE = "__Host-request-";
 const COOKIE = {
 	httpOnly: true,
 	path: "/",
@@ -66391,6 +67218,7 @@ function allowedRedirect(redirect) {
 		onSuccess: (target) => target.protocol === "http:" && (target.hostname === "127.0.0.1" || target.hostname === "localhost") && isEmpty$1(target.username) && isEmpty$1(target.password) && isEmpty$1(target.search) && isEmpty$1(target.hash)
 	});
 }
+var Authorizations = class extends Service$2()("@deslop/auth/service/Authorizations") {};
 var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 	static layer = (resource) => effectContext(gen(function* () {
 		const url = yield* pipe(String$1("AUTH_URL"), withDefault(AUTH_URL));
@@ -66414,6 +67242,7 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 	static layerIssuer = pipe(effectContext(gen(function* () {
 		const sql = yield* SqliteClient;
 		const random = yield* Crypto;
+		const changes = yield* sliding(1);
 		const router = yield* HttpRouter;
 		const client = filterStatusOk(yield* HttpClient);
 		const url = yield* pipe(String$1("AUTH_URL"), withDefault(AUTH_URL));
@@ -66424,6 +67253,7 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 			users: Array$1(String$2, "GITHUB_USERS")
 		});
 		yield* sql`CREATE TABLE IF NOT EXISTS auth_state (hash TEXT PRIMARY KEY, payload TEXT NOT NULL, expires_at INTEGER NOT NULL)`;
+		yield* sql`DELETE FROM auth_state WHERE json_extract(payload, '$._tag') = 'Request' AND json_extract(payload, '$.id') IS NULL`;
 		const hash = fnUntraced(function* (value) {
 			return encode(yield* random.digest("SHA-256", new TextEncoder().encode(value)));
 		});
@@ -66464,18 +67294,128 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 			if (stored._tag !== "Access" || !some(stored.resources, (value) => value === resource)) return yield* AuthError.make({ message: "The token is not valid for this app" });
 			return yield* allowed(stored.user);
 		}, rejected("Sign in first"));
-		const sameOrigin = gen(function* () {
-			if ((yield* HttpServerRequest).headers["origin"] !== new URL(url).origin) return yield* AuthError.make({
+		const checkOrigin = fnUntraced(function* (headers) {
+			if (headers["origin"] !== new URL(url).origin) return yield* AuthError.make({
 				error: "access_denied",
 				message: "The request comes from another origin"
 			});
 		});
+		const sameOrigin = flatMap$1(HttpServerRequest, (request) => checkOrigin(request.headers));
+		const requestRow = fnUntraced(function* (id) {
+			return yield* pipe(sql`SELECT hash, payload, expires_at AS "expiresAt" FROM auth_state WHERE json_extract(payload, '$.id') = ${id} AND expires_at > ${yield* currentTimeMillis}`, flatMap$1(decodeUnknownEffect(ArraySchema(AuthorizationRow))), map$2(head));
+		});
 		const requestState = fnUntraced(function* (id) {
-			if ((yield* HttpServerRequest).cookies[REQUEST_COOKIE] !== id) return yield* AuthError.make({ message: "Open the authorization link again" });
-			const stored = yield* load(id);
+			const row = yield* fromOption(yield* requestRow(id));
+			const stored = yield* decodeEffect(fromJsonString(Stored))(row.payload);
 			if (stored._tag !== "Request") return yield* AuthError.make({ message: "The authorization request expired" });
 			return stored;
+		}, rejected("The authorization request expired"));
+		const receiver = fnUntraced(function* (id, headers) {
+			const token = parseHeader(headers["cookie"] ?? "")[`${REQUEST_COOKIE}${id}`];
+			if (token === void 0) return yield* AuthError.make({ message: "Open the authorization link again" });
+			return yield* match$4(yield* requestRow(id), {
+				onNone: () => succeedNone,
+				onSome: fnUntraced(function* (row) {
+					if (row.hash !== (yield* hash(token))) return yield* AuthError.make({ message: "The authorization belongs to another browser" });
+					return some$1(row);
+				})
+			});
 		});
+		function watch(read, expires) {
+			return unwrap$2(gen(function* () {
+				const subscription = yield* subscribe(changes);
+				return unfold(none(), (previous) => gen(function* () {
+					yield* match$4(previous, {
+						onNone: () => void_$1,
+						onSome: (expiresAt) => raceFirst(take$1(subscription), match(expiresAt === Infinity, {
+							onFalse: () => flatMap$1(currentTimeMillis, (now) => sleep(max(0, expiresAt - now))),
+							onTrue: () => never$1
+						}))
+					});
+					const value = yield* read;
+					return [value, some$1(expires(value))];
+				}));
+			}));
+		}
+		function publicRequest(request, expiresAt) {
+			return {
+				...pipe(request, pick([
+					"clientName",
+					"createdAt",
+					"id",
+					"redirectUri",
+					"resources"
+				])),
+				expiresAt
+			};
+		}
+		const pending = fnUntraced(function* (headers) {
+			yield* session(headers);
+			const rows = yield* pipe(sql`SELECT payload, hash, expires_at AS "expiresAt" FROM auth_state WHERE json_extract(payload, '$._tag') = 'Request' AND json_extract(payload, '$.decision._tag') = 'Pending' AND expires_at > ${yield* currentTimeMillis} ORDER BY json_extract(payload, '$.createdAt') DESC, hash`, flatMap$1(decodeUnknownEffect(ArraySchema(AuthorizationRow))));
+			return yield* forEach$1(rows, fnUntraced(function* (row) {
+				return publicRequest(yield* decodeEffect(fromJsonString(Stored.cases.Request))(row.payload), row.expiresAt);
+			}), { concurrency: 1 });
+		}, rejected("Cannot read pending authorizations"));
+		const respond = fn("Authorizations.respond")(function* (params, headers) {
+			yield* checkOrigin(headers);
+			const user = yield* session(headers);
+			yield* sql.withTransaction(gen(function* () {
+				const request = yield* requestState(params.request);
+				if (request.decision._tag !== "Pending") return yield* AuthError.make({ message: "This authorization has already been answered" });
+				yield* sql`UPDATE auth_state SET payload = ${yield* encodeEffect(fromJsonString(Stored))({
+					...request,
+					decision: match(params.accept, {
+						onFalse: () => ({ _tag: "Denied" }),
+						onTrue: () => ({
+							_tag: "Approved",
+							user
+						})
+					})
+				})} WHERE json_extract(payload, '$.id') = ${params.request}`;
+			}));
+			yield* publish(changes, true);
+		}, rejected("Cannot answer the authorization request"));
+		const receive = fnUntraced(function* (id, headers) {
+			return yield* sql.withTransaction(flatMap$1(receiver(id, headers), (result) => match$4(result, {
+				onNone: () => succeed$4(AuthorizationStatus.make({ _tag: "Expired" })),
+				onSome: fnUntraced(function* (row) {
+					const request = yield* decodeEffect(fromJsonString(Stored))(row.payload);
+					if (request._tag === "Delivered") return AuthorizationStatus.make({
+						_tag: "Completed",
+						url: request.url
+					});
+					if (request._tag !== "Request") return yield* AuthError.make({ message: "Invalid authorization request" });
+					if (request.decision._tag === "Pending") return AuthorizationStatus.make({
+						_tag: "Waiting",
+						request: publicRequest(request, row.expiresAt)
+					});
+					const target = new URL(request.redirectUri);
+					target.searchParams.set("state", request.state);
+					target.searchParams.set("iss", issuer);
+					if (request.decision._tag === "Approved") target.searchParams.set("code", yield* save({
+						...pipe(request, pick([
+							"challenge",
+							"clientId",
+							"redirectUri",
+							"resources",
+							"state"
+						])),
+						_tag: "Code",
+						user: request.decision.user
+					}, 60));
+					else target.searchParams.set("error", "access_denied");
+					yield* sql`UPDATE auth_state SET payload = ${yield* encodeEffect(fromJsonString(Stored))({
+						_tag: "Delivered",
+						id,
+						url: target.href
+					})}, expires_at = ${yield* currentTimeMillis} + 60000 WHERE hash = ${row.hash}`;
+					return AuthorizationStatus.make({
+						_tag: "Completed",
+						url: target.href
+					});
+				})
+			})));
+		}, rejected("Cannot complete the authorization request"));
 		const grantTokens = fnUntraced(function* (grant, resources) {
 			yield* allowed(grant.user);
 			const seconds = match(contains(resources, "https://stash.mp281x.xyz"), {
@@ -66525,6 +67465,7 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 			return jsonUnsafe({
 				client_id: yield* save({
 					_tag: "Client",
+					name: params.client_name ?? "Unknown client",
 					redirects: params.redirect_uris
 				}, 31536e3),
 				grant_types: ["authorization_code", "refresh_token"],
@@ -66533,7 +67474,7 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 				token_endpoint_auth_method: "none"
 			}, { status: 201 });
 		})));
-		yield* router.add("GET", "/api/auth/oauth2/authorize", oauth(gen(function* () {
+		yield* router.add("GET", "/api/auth/oauth2/authorize", oauth(pipe(sql.withTransaction(gen(function* () {
 			const params = yield* pipe(schemaSearchParams(AuthorizeParams), rejected("Invalid authorization request"));
 			const registration = yield* load(params.client_id);
 			if (registration._tag !== "Client" || !contains(registration.redirects, params.redirect_uri)) return yield* AuthError.make({
@@ -66544,40 +67485,30 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 				error: "invalid_scope",
 				message: "Only Deslop access is supported"
 			});
-			const id = yield* save({
+			const now = yield* currentTimeMillis;
+			const id = encode(yield* random.randomBytes(16));
+			const token = yield* save({
 				_tag: "Request",
 				challenge: params.code_challenge,
 				clientId: params.client_id,
+				clientName: registration.name ?? "Unknown client",
+				createdAt: now,
+				decision: { _tag: "Pending" },
+				id,
 				redirectUri: params.redirect_uri,
 				resources: params.resource,
 				state: params.state
-			}, 600);
-			return setCookieUnsafe(redirect(`/?request=${id}`), REQUEST_COOKIE, id, {
+			}, 240);
+			return setCookieUnsafe(redirect(`/?request=${id}`), `${REQUEST_COOKIE}${id}`, token, {
 				...COOKIE,
-				maxAge: "10 minutes"
+				maxAge: "5 minutes"
 			});
-		})));
-		yield* router.add("GET", "/auth/request", oauth(gen(function* () {
-			const params = yield* pipe(schemaSearchParams(RequestParams), rejected("Open the authorization link again"));
-			return yield* schemaJson(Authorization)(yield* requestState(params.request));
-		})));
-		yield* router.add("POST", "/api/auth/oauth2/consent", oauth(sql.withTransaction(gen(function* () {
-			yield* sameOrigin;
+		})), tap(() => publish(changes, true)))));
+		yield* router.add("POST", "/api/auth/oauth2/consent", oauth(gen(function* () {
 			const params = yield* pipe(schemaBodyJson(ConsentParams), rejected("Invalid authorization response"));
-			const grant = yield* requestState(params.request);
-			const user = yield* session((yield* HttpServerRequest).headers);
-			yield* remove(params.request);
-			const target = new URL(grant.redirectUri);
-			target.searchParams.set("state", grant.state);
-			target.searchParams.set("iss", issuer);
-			if (params.accept) target.searchParams.set("code", yield* save({
-				...grant,
-				_tag: "Code",
-				user
-			}, 60));
-			else target.searchParams.set("error", "access_denied");
-			return expireCookieUnsafe(jsonUnsafe({ url: target.href }, { headers: { "cache-control": "no-store" } }), REQUEST_COOKIE, COOKIE);
-		}))));
+			yield* respond(params, (yield* HttpServerRequest).headers);
+			return empty();
+		})));
 		yield* router.add("POST", "/api/auth/oauth2/token", oauth(gen(function* () {
 			const params = yield* pipe(schemaBodyUrlParams(TokenParams), rejected("Invalid token request"));
 			return yield* sql.withTransaction(gen(function* () {
@@ -66637,7 +67568,7 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 		}));
 		yield* router.add("GET", "/auth/github", oauth(gen(function* () {
 			const params = yield* pipe(schemaSearchParams(SignInParams), rejected("Invalid sign-in request"));
-			if (params.request !== void 0) yield* requestState(params.request);
+			if (params.request !== void 0) yield* receiver(params.request, (yield* HttpServerRequest).headers);
 			const verifier = encode(yield* random.randomBytes(32));
 			const state = yield* save({
 				_tag: "Login",
@@ -66696,7 +67627,7 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 			yield* logWarning("GitHub sign-in failed", cause);
 			return expireCookieUnsafe(redirect(`/?${toString$1(fromInput({
 				error: "github",
-				request: (yield* HttpServerRequest).cookies[REQUEST_COOKIE]
+				request: void 0
 			}))}`), LOGIN_COOKIE, COOKIE);
 		}))));
 		yield* router.add("POST", "/auth/sign-out", oauth(gen(function* () {
@@ -66707,12 +67638,15 @@ var Auth = class Auth extends Service$2()("@deslop/auth/service/Auth") {
 				domain: pipe(new URL(url).hostname, split$1("."), drop$1(1), join$2("."))
 			});
 		})));
-		return provide(Auth.of({
+		return pipe(provide(Auth.of({
 			access,
 			user: fn("Auth.user")(function* (headers) {
 				return yield* session(headers);
 			})
-		}));
+		})), add$3(Authorizations, Authorizations.of({
+			pending: (headers) => watch(pending(headers), (requests) => reduce(requests, Infinity, (expiresAt, request) => min(expiresAt, request.expiresAt))),
+			wait: (id, headers) => pipe(watch(receive(id, headers), (status) => pipe(value(status), tag("Waiting", (value) => value.request.expiresAt), orElse(() => Infinity))), takeUntil((status) => status._tag !== "Waiting"))
+		})));
 	})), provide$3(unwrap$5(gen(function* () {
 		const fs = yield* FileSystem;
 		const path = yield* Path$1;
@@ -66777,7 +67711,7 @@ const layerNodeHttpServer = layerConfig(createServer, {
 });
 //#endregion
 //#region package.json
-var version = "0.1.1100";
+var version = "0.1.1102";
 //#endregion
 //#region src/services/telemetry/schema.ts
 var TelemetryError = class extends TaggedError()("TelemetryError", {
@@ -67030,7 +67964,7 @@ function traceView(entries, id) {
 	}));
 	const logs = filter$1(ordered, (entry) => entry.signal === "log");
 	const nodes = map$5(spans, (span) => {
-		const ancestors = reverse(unfold({
+		const ancestors = reverse(unfold$1({
 			entry: span.entry,
 			seen: make$46(span.entry.spanId)
 		}, (current) => pipe(get$9(byId, parentId(current.entry)), filter$3((parent) => !has(current.seen, parent.entry.spanId)), map$8((parent) => [parent, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deslop/scope",
-  "version": "0.1.1100",
+  "version": "0.1.1102",
   "description": "An Effect development debugger: an OTLP/HTTP JSON receiver whose traces and logs agents query over MCP.",
   "repository": {
     "type": "git",