@deslop/scope 0.1.1142 → 0.1.1155

package/dist/server.js

@@ -3169,9 +3169,9 @@ function Array_$1(item) {
 /**
 * @since 2.0.0
 */
-const TypeId$56 = "~effect/Option";
+const TypeId$57 = "~effect/Option";
 const CommonProto$1 = {
-	[TypeId$56]: { _A: (_) => _ },
+	[TypeId$57]: { _A: (_) => _ },
 	...PipeInspectableProto,
 	[Symbol.iterator]() {
 		return new SingleShotGen(this);
@@ -3221,7 +3221,7 @@ const NoneProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(Common
 	}
 });
 /** @internal */
-const isOption$1 = (input) => hasProperty(input, TypeId$56);
+const isOption$1 = (input) => hasProperty(input, TypeId$57);
 /** @internal */
 const isNone$1 = (fa) => fa._tag === "None";
 /** @internal */
@@ -3234,11 +3234,11 @@ const SomeImpl = function(value) {
 };
 SomeImpl.prototype = SomeProto;
 /** @internal */
-const some$2 = (value) => new SomeImpl(value);
+const some$1 = (value) => new SomeImpl(value);
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/internal/result.js
-const TypeId$55 = "~effect/Result";
+const TypeId$56 = "~effect/Result";
 const CommonProto = {
-	[TypeId$55]: {
+	[TypeId$56]: {
 		/* v8 ignore next 2 */
 		_A: (_) => _,
 		_E: (_) => _
@@ -3289,7 +3289,7 @@ const FailureProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(Com
 	}
 });
 /** @internal */
-const isResult$1 = (input) => hasProperty(input, TypeId$55);
+const isResult$1 = (input) => hasProperty(input, TypeId$56);
 /** @internal */
 const isFailure$2 = (result) => result._tag === "Failure";
 /** @internal */
@@ -3713,6 +3713,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**
@@ -3804,7 +3836,7 @@ const none = () => none$1;
 * @category constructors
 * @since 2.0.0
 */
-const some$1 = some$2;
+const some = some$1;
 /**
 * Determines whether the given value is an `Option`.
 *
@@ -3921,7 +3953,7 @@ const isSome = isSome$1;
 * @category pattern matching
 * @since 2.0.0
 */
-const match$5 = /*#__PURE__*/ dual(2, (self, { onNone, onSome }) => isNone(self) ? onNone() : onSome(self.value));
+const match$6 = /*#__PURE__*/ dual(2, (self, { onNone, onSome }) => isNone(self) ? onNone() : onSome(self.value));
 /**
 * Extracts the value from a `Some`, or evaluates a fallback thunk on `None`.
 *
@@ -4016,7 +4048,7 @@ const orElse$2 = /*#__PURE__*/ dual(2, (self, that) => isNone(self) ? that() : s
 * @category converting
 * @since 4.0.0
 */
-const fromNullishOr = (a) => a == null ? none() : some$1(a);
+const fromNullishOr = (a) => a == null ? none() : some(a);
 /**
 * Converts a possibly `undefined` value into an `Option`, leaving `null`
 * as a valid `Some`.
@@ -4048,7 +4080,7 @@ const fromNullishOr = (a) => a == null ? none() : some$1(a);
 * @category converting
 * @since 4.0.0
 */
-const fromUndefinedOr = (a) => a === void 0 ? none() : some$1(a);
+const fromUndefinedOr = (a) => a === void 0 ? none() : some(a);
 /**
 * Extracts the value from a `Some`, or returns `undefined` for `None`.
 *
@@ -4110,7 +4142,7 @@ const getOrUndefined$1 = /*#__PURE__*/ getOrElse(constUndefined);
 */
 const liftThrowable = (f) => (...a) => {
 	try {
-		return some$1(f(...a));
+		return some(f(...a));
 	} catch {
 		return none();
 	}
@@ -4183,7 +4215,7 @@ const getOrThrow$1 = /*#__PURE__*/ (/* @__PURE__ */ dual(2, (self, onNone) => {
 * @category mapping
 * @since 2.0.0
 */
-const map$8 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : some$1(f(self.value)));
+const map$8 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : some(f(self.value)));
 /**
 * Applies a function that returns an `Option` to the value of a `Some`,
 * flattening the result. Returns `None` if the input is `None`.
@@ -4264,7 +4296,7 @@ const flatMap$6 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(s
 * @category filtering
 * @since 2.0.0
 */
-const filter$3 = /*#__PURE__*/ dual(2, (self, predicate) => isNone(self) ? none() : predicate(self.value) ? some$1(self.value) : none());
+const filter$3 = /*#__PURE__*/ dual(2, (self, predicate) => isNone(self) ? none() : predicate(self.value) ? some(self.value) : none());
 /**
 * Lifts a `Predicate` or `Refinement` into the `Option` context: returns
 * `Some(value)` when the predicate holds, `None` otherwise.
@@ -4298,7 +4330,7 @@ const filter$3 = /*#__PURE__*/ dual(2, (self, predicate) => isNone(self) ? none(
 * @category lifting
 * @since 2.0.0
 */
-const liftPredicate = /*#__PURE__*/ dual(2, (b, predicate) => predicate(b) ? some$1(b) : none());
+const liftPredicate = /*#__PURE__*/ dual(2, (b, predicate) => predicate(b) ? some(b) : none());
 /**
 * Checks whether the value in a `Some` satisfies a predicate or refinement.
 *
@@ -4439,7 +4471,7 @@ const ServiceProto = {
 };
 const cacheKeys = /*#__PURE__*/ new Set();
 const ReferenceTypeId = "~effect/Context/Reference";
-const TypeId$54 = "~effect/Context";
+const TypeId$55 = "~effect/Context";
 const MaxDepth = 8;
 const FlattenAfterBaseHits = 8;
 const makeImpl$1 = (cacheRoot, base, overlay, depth) => {
@@ -4520,7 +4552,7 @@ const Proto$17 = {
 		return flatten$3(this);
 	},
 	...PipeInspectableProto,
-	[TypeId$54]: { _Services: (_) => _ },
+	[TypeId$55]: { _Services: (_) => _ },
 	toJSON() {
 		return {
 			_id: "Context",
@@ -4576,7 +4608,7 @@ const hasSameCache = (self, that) => self.cacheRoot === that.cacheRoot;
 * @category guards
 * @since 2.0.0
 */
-const isContext = (u) => hasProperty(u, TypeId$54);
+const isContext = (u) => hasProperty(u, TypeId$55);
 /**
 * Checks whether the provided argument is a `Reference`.
 *
@@ -4846,8 +4878,8 @@ const serviceNotFoundError = (service) => {
 */
 const getOption = /*#__PURE__*/ dual(2, (self, service) => {
 	const value = lookup(self, service.key);
-	if (value !== notFound$1) return some$1(value);
-	return isReference(service) ? some$1(getDefaultValue(service)) : none();
+	if (value !== notFound$1) return some(value);
+	return isReference(service) ? some(getDefaultValue(service)) : none();
 });
 /**
 * Merges two `Context`s into one.
@@ -5020,7 +5052,7 @@ const omit$2 = (...keys) => (self) => withFlat(self, (map) => {
 */
 const Reference = Service$2;
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/Duration.js
-const TypeId$53 = "~effect/Duration";
+const TypeId$54 = "~effect/Duration";
 const bigint0$3 = /*#__PURE__*/ BigInt(0);
 const bigint1$2 = /*#__PURE__*/ BigInt(1);
 const bigint2 = /*#__PURE__*/ BigInt(2);
@@ -5121,7 +5153,7 @@ const fromInputUnsafe$1 = (input) => {
 		}
 		case "object": {
 			if (input === null) break;
-			if (TypeId$53 in input) return input;
+			if (TypeId$54 in input) return input;
 			if (Array.isArray(input)) {
 				if (input.length !== 2 || !input.every(isNumber)) return invalid$2(input);
 				if (Number.isNaN(input[0]) || Number.isNaN(input[1])) return zero$2;
@@ -5192,7 +5224,7 @@ const zeroDurationValue = {
 const infinityDurationValue = { _tag: "Infinity" };
 const negativeInfinityDurationValue = { _tag: "NegativeInfinity" };
 const DurationProto = {
-	[TypeId$53]: TypeId$53,
+	[TypeId$54]: TypeId$54,
 	[symbol$3]() {
 		switch (this.value._tag) {
 			case "Millis": return hash(roundMillisToNanos(this.value.millis));
@@ -5276,7 +5308,7 @@ const make$70 = (input) => {
 * @category guards
 * @since 2.0.0
 */
-const isDuration = (u) => hasProperty(u, TypeId$53);
+const isDuration = (u) => hasProperty(u, TypeId$54);
 /**
 * Checks whether a Duration is finite (not infinite).
 *
@@ -5480,6 +5512,22 @@ const seconds = (seconds) => make$70(seconds * 1e3);
 */
 const minutes = (minutes) => make$70(minutes * 6e4);
 /**
+* Creates a Duration from days.
+*
+* **Example** (Creating durations from days)
+*
+* ```ts import.meta.vitest
+* import { Duration } from "effect"
+*
+* Duration.toMillis(Duration.days(1)) // => 86_400_000
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const days = (days) => make$70(days * 864e5);
+/**
 * Converts a Duration to milliseconds.
 *
 * **Example** (Converting durations to milliseconds)
@@ -5495,7 +5543,7 @@ const minutes = (minutes) => make$70(minutes * 6e4);
 * @category getters
 * @since 2.0.0
 */
-const toMillis = (self) => match$4(fromInputUnsafe$1(self), {
+const toMillis = (self) => match$5(fromInputUnsafe$1(self), {
 	onMillis: identity,
 	onNanos: (nanos) => nanosToUnit(nanos, 1e6),
 	onInfinity: () => Infinity,
@@ -5517,7 +5565,7 @@ const toMillis = (self) => match$4(fromInputUnsafe$1(self), {
 * @category getters
 * @since 2.0.0
 */
-const toSeconds = (self) => match$4(fromInputUnsafe$1(self), {
+const toSeconds = (self) => match$5(fromInputUnsafe$1(self), {
 	onMillis: (millis) => millis / 1e3,
 	onNanos: (nanos) => nanosToUnit(nanos, 1e9),
 	onInfinity: () => Infinity,
@@ -5589,7 +5637,7 @@ const toNanosUnsafe = (input) => {
 * @category pattern matching
 * @since 2.0.0
 */
-const match$4 = /*#__PURE__*/ dual(2, (self, options) => {
+const match$5 = /*#__PURE__*/ dual(2, (self, options) => {
 	switch (self.value._tag) {
 		case "Millis": return options.onMillis(self.value.millis);
 		case "Nanos": return options.onNanos(self.value.nanos);
@@ -6027,7 +6075,7 @@ const map$7 = /*#__PURE__*/ dual(2, (self, f) => isSuccess$1(self) ? succeed$9(f
 * @category pattern matching
 * @since 2.0.0
 */
-const match$3 = /*#__PURE__*/ dual(2, (self, { onFailure, onSuccess }) => isFailure$1(self) ? onFailure(self.failure) : onSuccess(self.success));
+const match$4 = /*#__PURE__*/ dual(2, (self, { onFailure, onSuccess }) => isFailure$1(self) ? onFailure(self.failure) : onSuccess(self.success));
 /**
 * Extracts the success value or throws the raw failure value `E`.
 *
@@ -6273,7 +6321,7 @@ const findFirst$1 = /*#__PURE__*/ dual(2, (self, f) => {
 	for (const a of self) {
 		const o = f(a, i);
 		if (isBoolean(o)) {
-			if (o) return some$1(a);
+			if (o) return some(a);
 		} else if (isSome(o)) return o;
 		i++;
 	}
@@ -6395,7 +6443,7 @@ const has$3 = /*#__PURE__*/ dual(2, (self, key) => Object.hasOwn(self, key));
 * @category getters
 * @since 2.0.0
 */
-const get$9 = /*#__PURE__*/ dual(2, (self, key) => Object.hasOwn(self, key) ? some$1(self[key]) : none());
+const get$9 = /*#__PURE__*/ dual(2, (self, key) => Object.hasOwn(self, key) ? some(self[key]) : none());
 /**
 * Maps a record into another record by applying a transformation function to each of its values.
 *
@@ -6647,6 +6695,42 @@ const fromIterable$6 = (collection) => Array$1.isArray(collection) ? collection
 */
 const ensure = (self) => Array$1.isArray(self) ? self : [self];
 /**
+* Pattern-matches on an array, handling empty and non-empty cases separately.
+*
+* **When to use**
+*
+* Use when you need to branch on whether an array is empty.
+*
+* **Details**
+*
+* `onNonEmpty` receives a `NonEmptyArray` for mutable arrays and a
+* `NonEmptyReadonlyArray` otherwise. Data-last calls default to the readonly
+* callback, so the returned function still accepts `ReadonlyArray`. Supports
+* both data-first and data-last usage.
+*
+* **Example** (Branching on emptiness)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* const describe = Array.match({
+*   onEmpty: () => "empty",
+*   onNonEmpty: ([head, ...tail]) => `head: ${head}, tail: ${tail.length}`
+* })
+*
+* describe([]) // => "empty"
+* describe([1, 2, 3]) // => "head: 1, tail: 2"
+* ```
+*
+* @see {@link matchLeft} — destructures into head + tail
+* @see {@link matchRight} — destructures into init + last
+*
+* @stability stable
+* @category pattern matching
+* @since 2.0.0
+*/
+const match$3 = /*#__PURE__*/ dual(2, (self, { onEmpty, onNonEmpty }) => isReadonlyArrayNonEmpty(self) ? onNonEmpty(self) : onEmpty());
+/**
 * Adds a single element to the end of an iterable, returning a `NonEmptyArray`.
 *
 * **When to use**
@@ -6670,7 +6754,35 @@ const ensure = (self) => Array$1.isArray(self) ? self : [self];
 * @since 2.0.0
 */
 const append$1 = /*#__PURE__*/ dual(2, (self, last) => [...self, last]);
-Array$1.isArray;
+/**
+* Checks whether a value is an `Array`.
+*
+* **When to use**
+*
+* Use to verify a value is a mutable array, narrowing its type to `Array<unknown>`.
+*
+* **Details**
+*
+* Acts as a type guard narrowing the input to `Array<unknown>` and delegates to
+* `globalThis.Array.isArray`.
+*
+* **Example** (Type-guarding an unknown value)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.isArray(null) // => false
+* Array.isArray([1, 2, 3]) // => true
+* ```
+*
+* @see {@link isArrayEmpty} — check for an empty array
+* @see {@link isArrayNonEmpty} — check for a non-empty array
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const isArray = Array$1.isArray;
 /**
 * Checks whether a mutable `Array` is empty, narrowing the type to `[]`.
 *
@@ -6810,7 +6922,7 @@ function isOutOfBounds(i, as) {
 */
 const get$8 = /*#__PURE__*/ dual(2, (self, index) => {
 	const i = Math.floor(index);
-	return isOutOfBounds(i, self) ? none() : some$1(self[i]);
+	return isOutOfBounds(i, self) ? none() : some(self[i]);
 });
 /**
 * Reads an element at the given index, throwing if the index is out of bounds.
@@ -7382,26 +7494,25 @@ const filter$1 = /*#__PURE__*/ dual(2, (self, predicate) => {
 */
 const reduce = /*#__PURE__*/ dual(3, (self, b, f) => fromIterable$6(self).reduce((b, a, i) => f(b, a, i), b));
 /**
-* Checks whether at least one element satisfies the predicate. Narrows the type
-* to `NonEmptyReadonlyArray` on success.
+* Returns the minimum element of a non-empty array according to the given
+* `Order`.
 *
-* **Example** (Testing for any match)
+* **Example** (Finding the minimum)
 *
 * ```ts import.meta.vitest
-* import { Array } from "effect"
+* import { Array, Order } from "effect"
 *
-* Array.some([1, 3, 4], (x) => x % 2 === 0) // => true
-* Array.some([1, 3, 5], (x) => x % 2 === 0) // => false
+* Array.min([3, 1, 2], Order.Number) // => 1
 * ```
 *
-* @see {@link every} — test if all elements match
-* @see {@link contains} — test for a specific value
+* @see {@link max} — find the maximum
+* @see {@link sort} — sort the entire array
 *
 * @stability stable
-* @category guards
+* @category getters
 * @since 2.0.0
 */
-const some = /*#__PURE__*/ dual(2, (self, predicate) => self.some(predicate));
+const min = /*#__PURE__*/ dual(2, (self, O) => self.reduce(min$1(O)));
 /**
 * Builds an array by repeatedly applying a function to a seed value. The
 * function returns `Option.some([element, nextSeed])` to continue, or
@@ -7521,6 +7632,24 @@ const dedupe = (self) => {
 	return out;
 };
 /**
+* Joins string elements with a separator.
+*
+* **Example** (Joining strings)
+*
+* ```ts import.meta.vitest
+* import { Array } from "effect"
+*
+* Array.join(["a", "b", "c"], "-") // => "a-b-c"
+* ```
+*
+* @see {@link intersperse} — insert separator elements without joining
+*
+* @stability stable
+* @category folding
+* @since 2.0.0
+*/
+const join$1 = /*#__PURE__*/ dual(2, (self, sep) => fromIterable$6(self).join(sep));
+/**
 * Computes the number of elements in an iterable that satisfy a predicate.
 *
 * **When to use**
@@ -9071,7 +9200,7 @@ const suspend$3 = /*#__PURE__*/ makePrimitive({
 /** @internal */
 const fromOption$1 = /*#__PURE__*/ dual((args) => args.length >= 2 || isOption(args[0]), (option, onNone) => isNone(option) ? onNone ? failSync$1(onNone) : fail$6(new NoSuchElementError("Effect.fromOption: Option.none")) : succeed$8(option.value));
 /** @internal */
-const fromResult$1 = /*#__PURE__*/ match$3({
+const fromResult$1 = /*#__PURE__*/ match$4({
 	onFailure: fail$6,
 	onSuccess: succeed$8
 });
@@ -9090,7 +9219,7 @@ const yieldNow$1 = /*#__PURE__*/ (/* @__PURE__ */ makePrimitive({
 	}
 }))(0);
 /** @internal */
-const succeedSome$1 = (a) => succeed$8(some$1(a));
+const succeedSome$1 = (a) => succeed$8(some(a));
 /** @internal */
 const succeedNone$1 = /*#__PURE__*/ succeed$8(/*#__PURE__*/ none());
 /** @internal */
@@ -9369,7 +9498,7 @@ const tapEffectCont = function(value) {
 	return new ContImpl(this.payload, succeedPayload, value);
 };
 /** @internal */
-const asSome$1 = (self) => map$4(self, some$1);
+const asSome$1 = (self) => map$4(self, some);
 /** @internal */
 const andThen$1 = /*#__PURE__*/ dual(2, (self, f) => new ContImpl(self, isEffect$1(f) ? returnPayload : andThenCont, f));
 /** @internal */
@@ -9546,9 +9675,11 @@ const provideService$1 = function() {
 };
 const provideServiceImpl = (self, service, implementation) => updateContext$1(self, add$3(service, implementation));
 /** @internal */
+const filterOrFail$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, predicate, orFailWith) => filterOrElse(self, predicate, orFailWith ? (a) => fail$6(orFailWith(a)) : () => fail$6(new NoSuchElementError())));
+/** @internal */
 const when$3 = /*#__PURE__*/ dual(2, (self, condition) => flatMap$3(condition, (pass) => pass ? asSome$1(self) : succeedNone$1));
 /** @internal */
-const forever$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, options) => whileLoop$1({
+const forever$2 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, options) => whileLoop$1({
 	while: constTrue,
 	body: constant(options?.disableYield ? self : flatMap$3(self, (_) => yieldNow$1)),
 	step: constVoid
@@ -10228,6 +10359,8 @@ const forEachConcurrent = /*#__PURE__*/ iterateConcurrentImpl({
 	}
 });
 /** @internal */
+const filterOrElse = /*#__PURE__*/ dual(3, (self, predicate, orElse) => flatMap$3(self, (a) => predicate(a) ? succeed$8(a) : orElse(a)));
+/** @internal */
 const forkChild$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, options) => withFiber$1((fiber) => {
 	interruptChildrenPatch();
 	return succeed$8(forkUnsafe$1(fiber, self, options?.startImmediately, false, options?.uninterruptible ?? false));
@@ -10429,12 +10562,12 @@ const NoopSpanProto = {
 const noopSpan = (options) => Object.assign(Object.create(NoopSpanProto), options);
 const filterDisablePropagation = (span) => {
 	if (!span) return none();
-	return get$10(span.annotations, DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(getOrUndefined$1(span.parent)) : none() : some$1(span);
+	return get$10(span.annotations, DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(getOrUndefined$1(span.parent)) : none() : some(span);
 };
 /** @internal */
 const makeSpanUnsafe = (fiber, name, options) => {
 	const disablePropagation = !fiber.cache.tracerEnabled || options?.annotations && get$10(options.annotations, DisablePropagation);
-	const parent = options?.parent !== void 0 ? some$1(options.parent) : options?.root ? none() : filterDisablePropagation(fiber.cache.span);
+	const parent = options?.parent !== void 0 ? some(options.parent) : options?.root ? none() : filterDisablePropagation(fiber.cache.span);
 	let span;
 	if (disablePropagation) span = noopSpan({
 		name,
@@ -11084,7 +11217,7 @@ const hasInterrupts$1 = exitHasInterrupts;
 */
 const asVoidAll = exitAsVoidAll;
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/Deferred.js
-const TypeId$52 = "~effect/Deferred";
+const TypeId$53 = "~effect/Deferred";
 /**
 * Checks whether a value is a `Deferred`.
 *
@@ -11097,9 +11230,9 @@ const TypeId$52 = "~effect/Deferred";
 * @category guards
 * @since 4.0.0
 */
-const isDeferred = (u) => hasProperty(u, TypeId$52);
+const isDeferred = (u) => hasProperty(u, TypeId$53);
 const DeferredProto = {
-	[TypeId$52]: {
+	[TypeId$53]: {
 		_A: identity,
 		_E: identity
 	},
@@ -11968,7 +12101,7 @@ const closeUnsafe = scopeCloseUnsafe;
 */
 const use$1 = scopeUse;
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/Layer.js
-const TypeId$51 = "~effect/Layer";
+const TypeId$52 = "~effect/Layer";
 const MemoMapTypeId = "~effect/Layer/MemoMap";
 const makeMemoMapEntry = (memoMap, layer) => {
 	const entry = {
@@ -11990,7 +12123,7 @@ const memoMapObserve = (entry, scope) => {
 	return true;
 };
 const LayerProto = {
-	[TypeId$51]: {
+	[TypeId$52]: {
 		_ROut: identity,
 		_E: identity,
 		_RIn: identity
@@ -13840,11 +13973,11 @@ const Clock = ClockRef;
 const currentTimeMillis = currentTimeMillis$1;
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/internal/dateTime.js
 /** @internal */
-const TypeId$50 = "~effect/DateTime";
+const TypeId$51 = "~effect/DateTime";
 /** @internal */
 const TimeZoneTypeId = "~effect/DateTime/TimeZone";
 const Proto$16 = {
-	[TypeId$50]: TypeId$50,
+	[TypeId$51]: TypeId$51,
 	pipe() {
 		return pipeArguments(this, arguments);
 	},
@@ -13878,7 +14011,7 @@ const ProtoTimeZone = {
 ({ ...ProtoTimeZone });
 ({ ...ProtoTimeZone });
 /** @internal */
-const isDateTime$1 = (u) => hasProperty(u, TypeId$50);
+const isDateTime$1 = (u) => hasProperty(u, TypeId$51);
 /** @internal */
 const isUtc$1 = (self) => self._tag === "Utc";
 const makeUtc = (epochMillis) => {
@@ -14021,12 +14154,12 @@ const max = /*#__PURE__*/ max$1(Number$5);
 * @since 2.0.0
 */
 const parse$2 = (s) => {
-	if (s === "NaN") return some$1(NaN);
-	if (s === "Infinity") return some$1(Infinity);
-	if (s === "-Infinity") return some$1(-Infinity);
+	if (s === "NaN") return some(NaN);
+	if (s === "Infinity") return some(Infinity);
+	if (s === "-Infinity") return some(-Infinity);
 	if (s.trim() === "") return none();
 	const n = Number$4(s);
-	return Number$4.isNaN(n) ? none() : some$1(n);
+	return Number$4.isNaN(n) ? none() : some(n);
 };
 globalThis.String;
 /**
@@ -14342,10 +14475,375 @@ const matchEffect$1 = /*#__PURE__*/ dual(2, (self, options) => matchCauseEffect$
 		return !isFailure$1(halt) ? options.onDone(halt.success.value) : options.onFailure(halt.failure);
 	}
 }));
+// ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/Schedule.js
+const TypeId$50 = "~effect/Schedule";
+/**
+* Context reference containing metadata for the currently running schedule step.
+*
+* **Details**
+*
+* Repeat, retry, stream, and channel scheduling operations provide this service
+* to effects run between schedule steps. The default value contains undefined
+* input and output values, zero duration, and zeroed timing fields before any
+* schedule step has produced metadata.
+*
+* @stability stable
+* @category services
+* @since 4.0.0
+*/
+const CurrentMetadata = /*#__PURE__*/ Reference("effect/Schedule/CurrentMetadata", { defaultValue: /*#__PURE__*/ constant({
+	input: void 0,
+	output: void 0,
+	duration: zero$2,
+	attempt: 0,
+	start: 0,
+	now: 0,
+	elapsed: 0,
+	elapsedSincePrevious: 0
+}) });
+const ScheduleProto = {
+	[TypeId$50]: {
+		_Out: identity,
+		_In: identity,
+		_Env: identity
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/**
+* Type guard that checks if a value is a Schedule.
+*
+* **Example** (Checking for schedules)
+*
+* ```ts import.meta.vitest
+* import { Schedule } from "effect"
+*
+* const schedule = Schedule.exponential("100 millis")
+* const notSchedule = { foo: "bar" }
+*
+* Schedule.isSchedule(schedule) // => true
+* Schedule.isSchedule(notSchedule) // => false
+* Schedule.isSchedule(null) // => false
+* Schedule.isSchedule(undefined) // => false
+* ```
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const isSchedule = (u) => hasProperty(u, TypeId$50);
+/**
+* Creates a Schedule from a step function that returns a Pull.
+*
+* **Example** (Creating a custom schedule from a step function)
+*
+* ```ts import.meta.vitest
+* import { Cause, Duration, Effect, Schedule } from "effect"
+*
+* const schedule = Schedule.fromStep(Effect.sync(() => {
+*   let count = 0
+*
+*   return (_now: number, _input: string) => {
+*     if (count >= 3) {
+*       return Cause.done(count)
+*     }
+*     return Effect.succeed([count++, Duration.millis(100)] as [number, Duration.Duration])
+*   }
+* }))
+*
+* const program = Effect.gen(function*() {
+*   const step = yield* Schedule.toStep(schedule)
+*   const [output] = yield* step(0, "input")
+*   return output
+* })
+*
+* await Effect.runPromise(program) // => 0
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromStep = (step) => {
+	const self = Object.create(ScheduleProto);
+	self.step = step;
+	return self;
+};
+const metadataFn = () => {
+	let n = 0;
+	let previous;
+	let start;
+	return (now, input) => {
+		if (start === void 0) start = now;
+		const elapsed = now - start;
+		const elapsedSincePrevious = previous === void 0 ? 0 : now - previous;
+		previous = now;
+		return {
+			input,
+			attempt: ++n,
+			start,
+			now,
+			elapsed,
+			elapsedSincePrevious
+		};
+	};
+};
+/**
+* Creates a Schedule from a step function that receives metadata about the schedule's execution.
+*
+* **Example** (Creating a metadata-aware schedule)
+*
+* ```ts import.meta.vitest
+* import { Cause, Duration, Effect, Schedule } from "effect"
+*
+* const firstThreeInputs = Schedule.fromStepWithMetadata(Effect.succeed((metadata: Schedule.InputMetadata<string>) => {
+*   if (metadata.attempt > 3) {
+*     return Cause.done("finished")
+*   }
+*
+*   return Effect.succeed([
+*     `attempt ${metadata.attempt}: ${metadata.input}`,
+*     Duration.millis(250)
+*   ] as [string, Duration.Duration])
+* }))
+*
+* const program = Effect.gen(function*() {
+*   const step = yield* Schedule.toStep(firstThreeInputs)
+*   const [output] = yield* step(0, "input")
+*   return output
+* })
+*
+* await Effect.runPromise(program) // => "attempt 1: input"
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const fromStepWithMetadata = (step) => fromStep(map$4(step, (f) => {
+	const meta = metadataFn();
+	return (now, input) => f(meta(now, input));
+}));
+/**
+* Extracts the step function from a Schedule.
+*
+* **Example** (Extracting a schedule step function)
+*
+* ```ts import.meta.vitest
+* import { Duration, Effect, Schedule } from "effect"
+*
+* // Extract step function from an existing schedule
+* const schedule = Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 3 }))
+*
+* const program = Effect.gen(function*() {
+*   const stepFn = yield* Schedule.toStep(schedule)
+*
+*   // Use the step function directly for custom logic. The timestamp is
+*   // supplied by the caller, so tests can pass a deterministic value.
+*   const now = 0
+*   return yield* stepFn(now, "input")
+* })
+*
+* await Effect.runPromise(program) // => [Duration.millis(100), Duration.millis(100)]
+* ```
+*
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+const toStep = (schedule) => catchCause$3(schedule.step, (cause) => succeed$8(() => failCause$6(cause)));
+/**
+* Extracts a step function from a `Schedule` that sleeps for each computed
+* delay and returns metadata for the completed step.
+*
+* **When to use**
+*
+* Use to drive a schedule manually while preserving the computed output,
+* delay, input, attempt, and elapsed timing metadata for each step.
+*
+* **Details**
+*
+* The returned step reads the current time from `Clock` when invoked, calls the
+* schedule step with that timestamp and input, sleeps for the returned
+* duration, and then yields `Metadata`.
+*
+* @see {@link toStep} for manually supplying the timestamp and handling the returned delay yourself
+* @see {@link toStepWithSleep} for the same automatic sleeping behavior when only the schedule output is needed
+*
+* @stability stable
+* @category destructors
+* @since 4.0.0
+*/
+const toStepWithMetadata = (schedule) => clockWith$1((clock) => map$4(toStep(schedule), (step) => {
+	const metaFn = metadataFn();
+	return (input) => suspend$3(() => {
+		const now = clock.currentTimeMillisUnsafe();
+		return flatMap$3(step(now, input), ([output, duration]) => {
+			const meta = metaFn(now, input);
+			meta.output = output;
+			meta.duration = duration;
+			return as$1(sleep$1(duration), meta);
+		});
+	});
+}));
+/**
+* Returns a new `Schedule` that outputs the inputs of the specified schedule.
+*
+* **Example** (Passing inputs through as outputs)
+*
+* ```ts import.meta.vitest
+* import { Effect, Schedule } from "effect"
+*
+* const inputSchedule = Schedule.passthrough(
+*   Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 3 }))
+* )
+* const program = Effect.gen(function*() {
+*   const step = yield* Schedule.toStep(inputSchedule)
+*   const [output] = yield* step(0, "input")
+*   return output
+* })
+*
+* await Effect.runPromise(program) // => "input"
+* ```
+*
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const passthrough$2 = (self) => fromStep(map$4(toStep(self), (step) => (now, input) => matchEffect$1(step(now, input), {
+	onSuccess: (result) => succeed$8([input, result[1]]),
+	onFailure: failCause$6,
+	onDone: () => done(input)
+})));
+/**
+* Returns a schedule that recurs continuously, each repetition spaced the
+* specified duration from the last run.
+*
+* **When to use**
+*
+* Use when each delay should start after the previous action completes.
+*
+* **Example** (Repeating with fixed spacing)
+*
+* ```ts import.meta.vitest
+* import { Duration, Effect, Schedule } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const step = yield* Schedule.toStep(Schedule.spaced("2 seconds"))
+*   return yield* step(0, undefined)
+* })
+*
+* await Effect.runPromise(program) // => [0, Duration.seconds(2)]
+* ```
+*
+* @see {@link fixed} for recurrence aligned to a regular cadence
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const spaced = (duration) => {
+	const decoded = fromInputUnsafe$1(duration);
+	return fromStepWithMetadata(succeed$8((meta) => succeed$8([meta.attempt - 1, decoded])));
+};
+const while_ = /*#__PURE__*/ dual(2, (self, predicate) => fromStep(map$4(toStep(self), (step) => {
+	const meta = metadataFn();
+	return (now, input) => flatMap$3(step(now, input), (result) => {
+		const [output, duration] = result;
+		const eff = predicate({
+			...meta(now, input),
+			output,
+			duration
+		});
+		return flatMap$3(isEffect$1(eff) ? eff : succeed$8(eff), (check) => check ? succeed$8(result) : done(output));
+	});
+})));
+/**
+* Returns a new `Schedule` that will recur forever.
+*
+* **Details**
+*
+* The output of the schedule is the current count of its repetitions thus far
+* (i.e. `0, 1, 2, ...`).
+*
+* **Example** (Repeating forever)
+*
+* ```ts import.meta.vitest
+* import { Effect, Schedule } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* const executions: Array<number> = []
+* const schedule = Schedule.forever.pipe(Schedule.upTo({ times: 2 }))
+* const program = Effect.sync(() => executions.push(executions.length + 1)).pipe(
+*   Effect.repeat(schedule),
+*   Effect.as(executions)
+* )
+*
+* await Effect.runPromise(Effect.provide(program, TestClock.layer())) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const forever$1 = /*#__PURE__*/ spaced(zero$2);
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/internal/layer.js
 const provideLayer = (self, layer, options) => scopedWith$1((scope) => flatMap$3(options?.local ? buildWithMemoMap(layer, makeMemoMapUnsafe(), scope) : buildWithScope(layer, scope), (context) => provideContext$3(self, context)));
 /** @internal */
 const provide$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, source, options) => isContext(source) ? provideContext$3(self, source) : provideLayer(self, Array.isArray(source) ? mergeAll$1(...source) : source, options));
+// ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/internal/schedule.js
+/** @internal */
+const repeatOrElse = /*#__PURE__*/ dual(3, (self, schedule, orElse) => flatMap$3(toStepWithMetadata(schedule), (step) => {
+	let meta = CurrentMetadata.defaultValue();
+	const loop = (input) => matchEffect$1(step(input), {
+		onSuccess(meta_) {
+			meta = meta_;
+			return flatMap$3(provideService$1(self, CurrentMetadata, meta), loop);
+		},
+		onFailure: failCause$6,
+		onDone: succeed$8
+	});
+	return catchCauseFilter$1(flatMap$3(provideService$1(self, CurrentMetadata, meta), loop), findRecoverableError, (error) => orElse(error, meta.attempt === 0 ? none() : some(meta)));
+}));
+/** @internal */
+const retryOrElse = /*#__PURE__*/ dual(3, (self, policy, orElse) => flatMap$3(toStepWithMetadata(policy), (step) => {
+	let meta = CurrentMetadata.defaultValue();
+	let lastError;
+	const loop = catchCauseFilter$1(suspend$3(() => provideService$1(self, CurrentMetadata, meta)), findRecoverableError, (error) => {
+		lastError = error;
+		return flatMap$3(step(error), (meta_) => {
+			meta = meta_;
+			return loop;
+		});
+	});
+	return catchDone(loop, (out) => internalCall(() => orElse(lastError, out)));
+}));
+/** @internal */
+const repeat$1 = /*#__PURE__*/ dual(2, (self, options) => {
+	const schedule = typeof options === "function" ? options(identity) : isSchedule(options) ? options : buildFromOptions(options);
+	return repeatOrElse(self, schedule, fail$6);
+});
+/** @internal */
+const retry$1 = /*#__PURE__*/ dual(2, (self, options) => {
+	const schedule = typeof options === "function" ? options(identity) : isSchedule(options) ? options : buildFromOptions(options);
+	return retryOrElse(self, schedule, fail$6);
+});
+const passthroughForever = /*#__PURE__*/ passthrough$2(forever$1);
+/** @internal */
+const buildFromOptions = (options) => {
+	let schedule = options.schedule ? passthrough$2(options.schedule) : passthroughForever;
+	if (options.while) schedule = while_(schedule, ({ input }) => {
+		const applied = options.while(input);
+		return isEffect$1(applied) ? applied : succeed$8(applied);
+	});
+	if (options.until) schedule = while_(schedule, ({ input }) => {
+		const applied = options.until(input);
+		return isEffect$1(applied) ? map$4(applied, (b) => !b) : succeed$8(!applied);
+	});
+	if (options.times !== void 0) schedule = while_(schedule, ({ attempt }) => succeed$8(attempt <= options.times));
+	return schedule;
+};
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/MutableHashMap.js
 const TypeId$49 = "~effect/MutableHashMap";
 const MutableHashMapProto = {
@@ -14441,7 +14939,7 @@ const empty$9 = () => {
 * @since 2.0.0
 */
 const get$7 = /*#__PURE__*/ dual(2, (self, key) => {
-	if (self.backing.has(key)) return some$1(self.backing.get(key));
+	if (self.backing.has(key)) return some(self.backing.get(key));
 	else if (isSimpleKey(key)) return none();
 	const hash$3 = hash(key);
 	const bucket = self.buckets.get(hash$3);
@@ -14452,7 +14950,7 @@ const isSimpleKey = (u) => typeof u !== "object" && typeof u !== "function";
 const getFromBucket = (self, bucket, key) => {
 	for (let i = 0, len = bucket.length; i < len; i++) if (equals$1(key, bucket[i])) {
 		const refKey = bucket[i];
-		return some$1(self.backing.get(refKey));
+		return some(self.backing.get(refKey));
 	}
 	return none();
 };
@@ -14561,7 +15059,7 @@ const getRefKey = (bucket, key) => {
 * @category mutations
 * @since 2.0.0
 */
-const remove$3 = /*#__PURE__*/ dual(2, (self, key_) => {
+const remove$5 = /*#__PURE__*/ dual(2, (self, key_) => {
 	if (isSimpleKey(key_)) {
 		self.backing.delete(key_);
 		return self;
@@ -16483,6 +16981,61 @@ const orDie$2 = orDie$3;
 */
 const tapCause = tapCause$1;
 /**
+* Retries typed failures from an effect according to a retry policy.
+*
+* **When to use**
+*
+* Use when you need to rerun an effect after transient typed failures, such as
+* network issues or temporary resource unavailability.
+*
+* **Details**
+*
+* The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
+* object using `schedule`, `times`, `while`, or `until`. If a retry eventually
+* succeeds, the returned effect succeeds with that value. If the policy stops
+* while the effect is still failing, the last failure is propagated.
+*
+* **Gotchas**
+*
+* The source effect is always evaluated once before any retry policy is
+* applied. For example, `Schedule.recurs(3)` allows up to three retries after
+* the initial attempt.
+*
+* Defects take precedence over typed errors. A failure whose cause contains a
+* defect is not retried and is propagated with every typed error converted to a
+* defect. A typed error alongside an interruption is retried.
+*
+* **Example** (Retrying with a schedule)
+*
+* ```ts import.meta.vitest
+* import { Data, Effect, Schedule } from "effect"
+*
+* class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
+*
+* let attempt = 0
+* const task = Effect.callback<string, AttemptError>((resume) => {
+*   attempt++
+*   if (attempt <= 2) {
+*     resume(Effect.fail(new AttemptError({ attempt })))
+*   } else {
+*     resume(Effect.succeed("Success!"))
+*   }
+* })
+*
+* const policy = Schedule.recurs(5)
+* const program = Effect.retry(task, policy)
+*
+* await Effect.runPromise(program) // => "Success!"
+* ```
+*
+* @see {@link retryOrElse} for a version that allows you to run a fallback.
+* @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const retry = retry$1;
+/**
 * Discards both the success and failure values of an effect.
 *
 * **When to use**
@@ -16747,6 +17300,38 @@ const race = race$1;
 */
 const raceFirst = raceFirst$1;
 /**
+* Filters an effect, failing with a custom error if the predicate fails.
+*
+* **Details**
+*
+* This function applies a predicate to the result of an effect. If the
+* predicate evaluates to `false`, the effect fails with either a custom
+* error (if `orFailWith` is provided) or a `NoSuchElementError`.
+*
+* **Example** (Filtering with a custom failure)
+*
+* ```ts import.meta.vitest
+* import { Effect } from "effect"
+*
+* // An effect that produces a number
+* const program = Effect.succeed(5)
+*
+* // Filter for even numbers, fail for odd numbers
+* const filtered = Effect.filterOrFail(
+*   program,
+*   (n) => n % 2 === 0,
+*   (n) => `Expected even number, got ${n}`
+* )
+*
+* Effect.runSync(Effect.flip(filtered)) // => "Expected even number, got 5"
+* ```
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const filterOrFail = filterOrFail$1;
+/**
 * Runs an effect conditionally based on the result of an effectful boolean
 * condition.
 *
@@ -17804,7 +18389,93 @@ const uninterruptibleMask = uninterruptibleMask$1;
 * @category repetition
 * @since 2.0.0
 */
-const forever = forever$1;
+const forever = forever$2;
+/**
+* Repeats an effect based on a specified schedule or until the first failure.
+*
+* **When to use**
+*
+* Use to rerun an effect after successful executions.
+*
+* **Details**
+*
+* This function executes an effect repeatedly according to the given schedule.
+* Each repetition occurs after the initial execution of the effect, meaning
+* that the schedule determines the number of additional repetitions. For
+* example, using `Schedule.once` will result in the effect being executed twice
+* (once initially and once as part of the repetition).
+*
+* If the effect succeeds, it is repeated according to the schedule. If it
+* fails, the repetition stops immediately, and the failure is returned.
+*
+* The schedule can also specify delays between repetitions, making it useful
+* for tasks like retrying operations with backoff, periodic execution, or
+* performing a series of dependent actions.
+*
+* You can combine schedules for more advanced repetition logic, such as adding
+* delays, limiting recursions, or dynamically adjusting based on the outcome of
+* each execution.
+*
+* **Gotchas**
+*
+* The source effect is always evaluated once before the schedule is stepped.
+* The schedule controls additional repetitions, not the initial execution.
+*
+* If the effect or policy fails with a cause that contains a defect, the
+* failure is propagated with every typed error converted to a defect.
+* An interruption alongside a typed error does not block the typed error path.
+*
+* **Example** (Repeating successful effects with a schedule)
+*
+* ```ts import.meta.vitest
+* // Success Example
+* import { Effect, Schedule } from "effect"
+* const output: Array<unknown> = []
+*
+* const action = Effect.sync(() => { output.push("success") })
+* const policy = Schedule.recurs(2)
+* const program = Effect.repeat(action, policy)
+*
+* void output.push(Effect.runSync(program))
+* output // => ["success", "success", "success", 2]
+* ```
+*
+* **Example** (Stopping repetition on failure)
+*
+* ```ts import.meta.vitest
+* // Failure Example
+* import { Effect, Schedule } from "effect"
+* const output: Array<unknown> = []
+*
+* let count = 0
+*
+* // Define a callback effect that simulates an action with possible failures
+* const action = Effect.callback<string, string>((resume) => {
+*   if (count > 1) {
+*     void output.push("failure")
+*     resume(Effect.fail("Uh oh!"))
+*   } else {
+*     count++
+*     void output.push("success")
+*     resume(Effect.succeed("yay!"))
+*   }
+* })
+*
+* const policy = Schedule.recurs(2)
+* const program = Effect.repeat(action, policy)
+*
+* void output.push((await Effect.runPromiseExit(program))._tag)
+* output // => ["success", "success", "failure", "Failure"]
+* ```
+*
+* @see {@link retry} for failure-based repetition
+* @see {@link repeatOrElse} for fallback handling when repetition fails
+*
+* @stability stable
+* @category repetition
+* @since 2.0.0
+*/
+const repeat = repeat$1;
 /**
 * Adds an annotation to the current span if available.
 *
@@ -19646,7 +20317,7 @@ const BigInt$4 = globalThis.BigInt;
 */
 const toNumber = (b) => {
 	if (b > BigInt$4(Number.MAX_SAFE_INTEGER) || b < BigInt$4(Number.MIN_SAFE_INTEGER)) return none();
-	return some$1(Number(b));
+	return some(Number(b));
 };
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/ByteSize.js
 const bigint0$1 = /*#__PURE__*/ BigInt(0);
@@ -20816,7 +21487,7 @@ const filter = (self, f) => {
 * @category mutations
 * @since 4.0.0
 */
-const remove$2 = (self, value) => filter(self, (v) => v !== value);
+const remove$4 = (self, value) => filter(self, (v) => v !== value);
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/PubSub.js
 const TypeId$44 = "~effect/PubSub";
 const SubscriptionTypeId = "~effect/PubSub/Subscription";
@@ -21096,7 +21767,7 @@ const pollForItem = (self) => callback$1((resume) => {
 	self.strategy.completePollersUnsafe(self.pubsub, self.subscribers, self.subscription, self.pollers);
 	if (deferred.effect) return resume(deferred.effect);
 	deferred.resumes = [resume];
-	return sync(() => remove$2(self.pollers, deferred));
+	return sync(() => remove$4(self.pollers, deferred));
 });
 const AbsentValue = /*#__PURE__*/ Symbol.for("effect/PubSub/AbsentValue");
 const addSubscribers = (subscribers, subscription, pollers) => {
@@ -22299,7 +22970,7 @@ const take = (self) => suspendTake(() => takeUnsafe(self) ?? andThen$1(awaitTake
 const poll = (self) => suspendTake(() => {
 	const result = takeUnsafe(self);
 	if (result === void 0) return succeed$8(none());
-	if (result._tag === "Success") return succeed$8(some$1(result.value));
+	if (result._tag === "Success") return succeed$8(some(result.value));
 	return succeed$8(none());
 });
 /**
@@ -23520,19 +24191,6 @@ const catchCauseFilter = /*#__PURE__*/ dual(3, (self, filter, f) => catchCause$1
 }));
 const catch_$1 = /*#__PURE__*/ dual(2, (self, f) => catchCauseFilter(self, findRecoverableError, (e) => f(e)));
 /**
-* Transforms the typed errors of a channel using the specified function.
-*
-* **Details**
-*
-* Maps every typed error in the cause, preserving defects, interrupts and
-* reason order. Unlike typed recovery, mapping does not convert errors to defects.
-*
-* @stability stable
-* @category error handling
-* @since 2.0.0
-*/
-const mapError$1 = /*#__PURE__*/ dual(2, (self, f) => transformPull$1(self, (pull) => succeed$4(mapError$2(pull, (err) => isDone(err) ? err : f(err)))));
-/**
 * Converts all errors in the channel to defects (unrecoverable failures).
 * This is useful when you want to treat errors as programming errors.
 *
@@ -23772,7 +24430,7 @@ const splitLines$1 = () => fromTransform$1((upstream, _scope) => sync(() => {
 			onSuccess: loop,
 			onFailure: failCause$3,
 			onDone: (leftover) => {
-				done$13 = some$1(leftover);
+				done$13 = some(leftover);
 				if (stringBuilder.length > 0) {
 					const last = stringBuilder;
 					stringBuilder = "";
@@ -24036,51 +24694,6 @@ const provideContext$1 = /*#__PURE__*/ dual(2, (self, context) => fromTransform$
 */
 const runForEach$1 = /*#__PURE__*/ dual(2, (self, f) => runWith(self, (pull) => forever(flatMap$1(pull, f), { disableYield: true })));
 /**
-* Concatenates a channel's `Uint8Array` chunks into a single `Uint8Array`.
-*
-* **Gotchas**
-*
-* This materializes the full content in memory. The source channel must not
-* reuse or mutate emitted buffers, which are retained until collection completes.
-*
-* **Example** (Joining channel byte chunks)
-*
-* ```ts import.meta.vitest
-* import { Channel, Effect } from "effect"
-*
-* const channel = Channel.fromArray([
-*   [new Uint8Array([1, 2])],
-*   [new Uint8Array([3, 4])]
-* ] as const)
-*
-* const bytes = Effect.runSync(Channel.mkUint8Array(channel))
-* Array.from(bytes) // => [1, 2, 3, 4]
-* ```
-*
-* @stability stable
-* @category running
-* @since 4.0.0
-*/
-const mkUint8Array$1 = (self) => map$2(runFold(self, () => ({
-	bytes: 0,
-	arrays: []
-}), (acc, chunk) => {
-	for (let i = 0; i < chunk.length; i++) {
-		acc.bytes += chunk[i].length;
-		acc.arrays.push(chunk[i]);
-	}
-	return acc;
-}), ({ arrays, bytes }) => {
-	const result = new Uint8Array(bytes);
-	let offset = 0;
-	for (let i = 0; i < arrays.length; i++) {
-		const array = arrays[i];
-		result.set(array, offset);
-		offset += array.length;
-	}
-	return result;
-});
-/**
 * Runs a channel to completion and returns the last output element in an
 * `Option`.
 *
@@ -24564,7 +25177,7 @@ const removeInterrupted = (self, key, entry, context) => {
 	if (self.state._tag === "Closed") return;
 	const o = get$7(self.state.map, key);
 	if (o._tag === "None" || o.value !== entry) return;
-	remove$3(self.state.map, key);
+	remove$5(self.state.map, key);
 	if (entry.refCount > 0) return;
 	closeEntry(entry).pipe(runForkWith(context), runIn(self.scope));
 };
@@ -24576,7 +25189,7 @@ const release$1 = (self, key, entry) => withFiber((fiber) => {
 	const o = get$7(self.state.map, key);
 	if (o._tag === "None" || o.value !== entry) return closeEntry(entry);
 	else if (isZero$1(entry.idleTimeToLive)) {
-		remove$3(self.state.map, key);
+		remove$5(self.state.map, key);
 		return closeEntry(entry);
 	} else if (!isFinite$1(entry.idleTimeToLive)) return void_$1;
 	const clock = fiber.getRef(Clock);
@@ -24589,7 +25202,7 @@ const release$1 = (self, key, entry) => withFiber((fiber) => {
 			if (self.state._tag === "Closed" || entry.refCount > 0) return void_$1;
 			const o = get$7(self.state.map, key);
 			if (o._tag === "None" || o.value !== entry) return void_$1;
-			remove$3(self.state.map, key);
+			remove$5(self.state.map, key);
 			return close(entry.scope, void_$2);
 		}
 		return flatMap$1(restore(clock.sleep(millis(remaining))), () => loop(restore));
@@ -25451,36 +26064,6 @@ const merge$1 = /*#__PURE__*/ dual((args) => isStream(args[0]) && isStream(args[
 const catchCause = /*#__PURE__*/ dual(2, (self, f) => self.channel.pipe(catchCause$1((cause) => f(cause).channel), fromChannel));
 const catch_ = /*#__PURE__*/ dual(2, (self, f) => fromChannel(catch_$1(self.channel, (error) => f(error).channel)));
 /**
-* Transforms the errors emitted by this stream using `f`.
-*
-* **Details**
-*
-* Maps every typed error in the cause, preserving defects, interrupts and
-* reason order. Unlike typed recovery, mapping does not convert errors to defects.
-*
-* **Example** (Mapping stream errors)
-*
-* ```ts import.meta.vitest
-* import { Effect, Stream } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const result = yield* Stream.fail("bad").pipe(
-*     Stream.mapError((error) => `mapped: ${error}`),
-*     Stream.catch((error) => Stream.make(`recovered from ${error}`)),
-*     Stream.runCollect
-*   )
-*   result // => [ 'recovered from mapped: bad' ]
-* })
-*
-* await Effect.runPromise(program)
-* ```
-*
-* @stability stable
-* @category error handling
-* @since 2.0.0
-*/
-const mapError = /*#__PURE__*/ dual(2, (self, f) => fromChannel(mapError$1(self.channel, f)));
-/**
 * Turns typed failures into defects, making the stream infallible.
 *
 * **Example** (Turning failures into defects)
@@ -25591,42 +26174,6 @@ const transduce = /*#__PURE__*/ dual(2, (self, sink) => transformPull(self, (ups
 	return suspend$2(() => done$10 ? done$10 : pull);
 })));
 /**
-* Pipes this stream through a channel that consumes and emits chunked elements.
-*
-* **Details**
-*
-* The channel receives `NonEmptyReadonlyArray` chunks and can transform both the
-* output elements and error type.
-*
-* **Example** (Piping through a channel)
-*
-* ```ts import.meta.vitest
-* import { Array, Channel, Effect, Stream } from "effect"
-*
-* type NumberChunk = readonly [number, ...Array<number>]
-*
-* const doubleChunks = Channel.identity<NumberChunk, never, unknown>().pipe(
-*   Channel.map((chunk) => Array.map(chunk, (n) => n * 2))
-* )
-*
-* const program = Effect.gen(function*() {
-*   const result = yield* Stream.fromArray([1, 2, 3]).pipe(
-*     Stream.rechunk(2),
-*     Stream.pipeThroughChannel(doubleChunks),
-*     Stream.runCollect
-*   )
-*   result // => [ 2, 4, 6 ]
-* })
-*
-* await Effect.runPromise(program)
-* ```
-*
-* @stability stable
-* @category sequencing
-* @since 2.0.0
-*/
-const pipeThroughChannel = /*#__PURE__*/ dual(2, (self, channel) => fromChannel(pipeTo$1(self.channel, channel)));
-/**
 * Pipes values through the provided channel while preserving this stream's
 * failures alongside any channel failures.
 *
@@ -25965,33 +26512,6 @@ const runForEachArray = /*#__PURE__*/ dual(2, (self, f) => runForEach$1(self.cha
 */
 const mkString = (self) => runFold(self.channel, () => "", (acc, chunk) => acc + chunk.join(""));
 /**
-* Concatenates the stream's `Uint8Array` chunks into a single `Uint8Array`.
-*
-* **Gotchas**
-*
-* This materializes the full content in memory. The source stream must not
-* reuse or mutate emitted buffers, which are retained until collection completes.
-*
-* **Example** (Joining Uint8Array chunks)
-*
-* ```ts import.meta.vitest
-* import { Effect, Stream } from "effect"
-*
-* const stream = Stream.make(new Uint8Array([1, 2]), new Uint8Array([3, 4]))
-* const program = Effect.gen(function*() {
-*   const bytes = yield* Stream.mkUint8Array(stream)
-*   const values = Array.from(bytes) // => [1, 2, 3, 4]
-* })
-*
-* await Effect.runPromise(program)
-* ```
-*
-* @stability stable
-* @category destructors
-* @since 4.0.0
-*/
-const mkUint8Array = (self) => mkUint8Array$1(self.channel);
-/**
 * Converts the stream to a `ReadableStream` using the provided services.
 *
 * **When to use**
@@ -26196,7 +26716,7 @@ const make$55 = (impl) => FileSystem.of({
 		return fromPull(succeed$4(flatMap$1(suspend$2(() => {
 			if (bytesToRead !== void 0 && bytesToRead <= totalBytesRead) return done();
 			return bytesToRead !== void 0 && bytesToRead - totalBytesRead < chunkSize ? file.readAlloc(Number(bytesToRead - totalBytesRead)) : readChunk;
-		}), match$5({
+		}), match$6({
 			onNone: () => done(),
 			onSome: (buf) => {
 				totalBytesRead += BigInt(buf.length);
@@ -26401,7 +26921,7 @@ const make$54 = (impl) => Path$1.of({
 		const base = impl.resolve(root);
 		const candidate = impl.resolve(base, input);
 		const relative = impl.relative(base, candidate);
-		return relative === ".." || relative.startsWith(`..${impl.sep}`) || impl.isAbsolute(relative) ? none() : some$1(candidate);
+		return relative === ".." || relative.startsWith(`..${impl.sep}`) || impl.isAbsolute(relative) ? none() : some(candidate);
 	}
 });
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/internal/schema/annotations.js
@@ -26472,7 +26992,7 @@ const missingExit = /*#__PURE__*/ succeed$1(missing);
 /** @internal */
 const sameExit = /*#__PURE__*/ succeed$1(missing);
 /** @internal */
-const toOption = (value) => value === missing ? none() : some$1(value);
+const toOption = (value) => value === missing ? none() : some(value);
 /** @internal */
 const fromOptionExit = (option) => option._tag === "None" ? missingExit : succeed$1(option.value);
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/SchemaIssue.js
@@ -27638,7 +28158,7 @@ function omit$1() {
 function withDefault$2(defaultValue) {
 	return transformOptionalEffect((o) => {
 		const filtered = filter$3(o, isNotUndefined);
-		return isSome(filtered) ? succeed$4(filtered) : mapEager(defaultValue, some$1);
+		return isSome(filtered) ? succeed$4(filtered) : mapEager(defaultValue, some);
 	});
 }
 /**
@@ -30828,7 +31348,7 @@ const unknownToStringTree = /*#__PURE__*/ new Link(/* @__PURE__ */ new Declarati
 */
 function nominal() {
 	return Object.assign((input) => input, {
-		option: (input) => some$1(input),
+		option: (input) => some(input),
 		result: (input) => succeed$9(input),
 		is: (_) => true
 	});
@@ -32787,28 +33307,12 @@ const merge = /*#__PURE__*/ dual(2, (self, headers) => {
 * @category combinators
 * @since 4.0.0
 */
-const remove$1 = /*#__PURE__*/ dual(2, (self, key) => {
+const remove$3 = /*#__PURE__*/ dual(2, (self, key) => {
 	const out = make$46(self);
 	delete out[key.toLowerCase()];
 	return out;
 });
 /**
-* Returns a new `Headers` collection with each named header removed.
-*
-* **Details**
-*
-* Each provided header name is normalized to lowercase before removal.
-*
-* @stability unstable
-* @category combinators
-* @since 4.0.0
-*/
-const removeMany = /*#__PURE__*/ dual(2, (self, keys) => {
-	const out = make$46(self);
-	for (const key of keys) delete out[key.toLowerCase()];
-	return out;
-});
-/**
 * Returns a plain record with selected header values wrapped in `Redacted`.
 *
 * **Details**
@@ -33099,7 +33603,7 @@ var LeafNode = class LeafNode extends Node {
 		return 1;
 	}
 	get(_shift, hash, key) {
-		if (this.hash === hash && equals$1(this.key, key)) return some$1(this.value);
+		if (this.hash === hash && equals$1(this.key, key)) return some(this.value);
 		return none();
 	}
 	has(_shift, hash, key) {
@@ -33150,7 +33654,7 @@ var CollisionNode = class CollisionNode extends Node {
 	}
 	get(_shift, hash, key) {
 		if (this.hash !== hash) return none();
-		for (const [k, v] of this.entries) if (equals$1(k, key)) return some$1(v);
+		for (const [k, v] of this.entries) if (equals$1(k, key)) return some(v);
 		return none();
 	}
 	has(_shift, hash, key) {
@@ -33557,6 +34061,24 @@ const keys = (self) => new HashMapIterator(self._root, identity);
 const values$1 = (self) => new HashMapIterator(self._root, toValue);
 /** @internal */
 const size$1 = (self) => self.size;
+const removeHash = (self, key, hash) => {
+	const impl = self;
+	const removed = { value: false };
+	const edit = impl._editable ? impl._edit : NaN;
+	const newRoot = impl._root.remove(edit, 0, hash, key, removed);
+	if (!removed.value) return self;
+	if (impl._editable) {
+		impl._root = newRoot ?? emptyNode;
+		impl._size--;
+		return self;
+	}
+	if (newRoot === void 0) return empty$4();
+	return new HashMapImpl(false, impl._edit, newRoot, impl._size - 1);
+};
+/** @internal */
+const remove$2 = /*#__PURE__*/ dual(2, (self, key) => {
+	return removeHash(self, key, hash(key));
+});
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/HashMap.js
 /**
 * Stores key/value entries in an immutable hash map.
@@ -33625,6 +34147,26 @@ const set = set$1;
 * @since 2.0.0
 */
 const values = values$1;
+/**
+* Removes the entry for the specified key in the `HashMap` using the internal
+* hashing function.
+*
+* **Example** (Removing a key)
+*
+* ```ts import.meta.vitest
+* import { HashMap } from "effect"
+*
+* const map1 = HashMap.make(["a", 1], ["b", 2], ["c", 3])
+* const map2 = HashMap.remove(map1, "b")
+*
+* map2 // => HashMap.make(["a", 1], ["c", 3])
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const remove$1 = remove$2;
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/internal/hashSet.js
 /**
 * @since 2.0.0
@@ -34301,7 +34843,7 @@ function makeOption(schema) {
 	const parser = makeEffect(schema);
 	return (input, options) => {
 		const exit = runSyncExit(parser(input, options));
-		if (isSuccess(exit)) return some$1(exit.value);
+		if (isSuccess(exit)) return some(exit.value);
 		getSchemaIssueOrThrow(exit.cause, "Option adapter can only return none for schema issues");
 		return none();
 	};
@@ -35830,6 +36372,35 @@ function toRepresentations(asts, options) {
 }
 // ../../node_modules/.pnpm/effect@4.0.6/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**
@@ -38136,7 +38707,7 @@ function Cause(error, defect) {
 }
 const dateTimeUtcFromString = /*#__PURE__*/ transformEffect({
 	decode: (s, options) => {
-		return match$5(make$53(s), {
+		return match$6(make$53(s), {
 			onNone: () => fail$3(new InvalidValue({ expected: "a valid UTC DateTime string" }, s, options)),
 			onSome: (result) => succeed$4(toUtc(result))
 		});
@@ -38197,7 +38768,7 @@ const DateTimeUtc = /*#__PURE__*/ declare((u) => isDateTime(u) && isUtc(u), {
 	toFormatter: () => (utc) => utc.toString()
 });
 const durationFromString = /*#__PURE__*/ transformEffect({
-	decode: (s, options) => match$5(fromInput$3(s), {
+	decode: (s, options) => match$6(fromInput$3(s), {
 		onNone: () => fail$3(new InvalidValue({ expected: "a valid Duration string" }, s, options)),
 		onSome: succeed$4
 	}),
@@ -39259,25 +39830,6 @@ var EmptyBodyError = class extends (/*#__PURE__*/ TaggedError$1("EmptyBodyError"
 };
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/HttpMethod.js
 /**
-* Defines supported HTTP method names for the unstable HTTP modules.
-*
-* Values are uppercase string literals such as `"GET"` and `"POST"`, matching
-* the method tokens used by HTTP requests and routes. This module also includes
-* helpers for checking whether a method can carry a request body and whether an
-* unknown value is one of the supported methods.
-*
-* @stability unstable
-* @since 4.0.0
-*/
-/**
-* Returns `true` when a method can carry a request body and narrows it to `HttpMethod.WithBody`.
-*
-* @stability unstable
-* @category guards
-* @since 4.0.0
-*/
-const hasBody = (method) => method !== "GET" && method !== "HEAD" && method !== "OPTIONS" && method !== "TRACE";
-/**
 * Provides tuples mapping each supported HTTP method to its short
 * request-constructor name.
 *
@@ -39306,9 +39858,9 @@ const allShort = [
 * @internal
 */
 const updateHeaders = (headers, body) => {
-	if (body._tag === "Empty" || body._tag === "FormData") return remove$1(remove$1(headers, "content-type"), "content-length");
-	headers = body.contentType === void 0 ? remove$1(headers, "content-type") : set$2(headers, "content-type", body.contentType);
-	return body.contentLength === void 0 ? remove$1(headers, "content-length") : set$2(headers, "content-length", body.contentLength.toString());
+	if (body._tag === "Empty" || body._tag === "FormData") return remove$3(remove$3(headers, "content-type"), "content-length");
+	headers = body.contentType === void 0 ? remove$3(headers, "content-type") : set$2(headers, "content-type", body.contentType);
+	return body.contentLength === void 0 ? remove$3(headers, "content-length") : set$2(headers, "content-length", body.contentLength.toString());
 };
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/Url.js
 /**
@@ -39499,7 +40051,7 @@ const setUrlParams = /*#__PURE__*/ dual(2, (self, input) => makeWith$1(self.meth
 * @category combinators
 * @since 4.0.0
 */
-const setHash = /*#__PURE__*/ dual(2, (self, hash) => makeWith$1(self.method, self.url, self.urlParams, some$1(hash), self.headers, self.body));
+const setHash = /*#__PURE__*/ dual(2, (self, hash) => makeWith$1(self.method, self.url, self.urlParams, some(hash), self.headers, self.body));
 /**
 * Sets the request body and updates `Content-Type` and `Content-Length` headers from the body metadata when available.
 *
@@ -39519,7 +40071,7 @@ const setBody$1 = /*#__PURE__*/ dual(2, (self, body) => {
 */
 function toUrl(self) {
 	const r = make$39(self.url, self.urlParams, getOrUndefined$1(self.hash));
-	if (isSuccess$1(r)) return some$1(r.success);
+	if (isSuccess$1(r)) return some(r.success);
 	return none();
 }
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/HttpIncomingMessage.js
@@ -39760,7 +40312,7 @@ var WebHttpClientResponse = class extends Class$2 {
 * @since 4.0.0
 */
 const toHeaders = (span) => fromRecordUnsafe({
-	b3: `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${match$5(span.parent, {
+	b3: `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${match$6(span.parent, {
 		onNone: () => "",
 		onSome: (parent) => `-${parent.spanId}`
 	})}`,
@@ -39801,7 +40353,7 @@ const b3 = (headers) => {
 	if (!("b3" in headers)) return none();
 	const parts = headers["b3"].split("-");
 	if (parts.length < 2 || isB3Ids(parts[0], parts[1]) === false) return none();
-	return some$1(externalSpan({
+	return some(externalSpan({
 		traceId: parts[0],
 		spanId: parts[1],
 		sampled: parts[2] ? parts[2] === "1" || parts[2] === "d" : true
@@ -39821,7 +40373,7 @@ const b3 = (headers) => {
 */
 const xb3 = (headers) => {
 	if (!headers["x-b3-traceid"] || !headers["x-b3-spanid"] || isB3Ids(headers["x-b3-traceid"], headers["x-b3-spanid"]) === false) return none();
-	return some$1(externalSpan({
+	return some(externalSpan({
 		traceId: headers["x-b3-traceid"],
 		spanId: headers["x-b3-spanid"],
 		sampled: headers["x-b3-flags"] === "1" || (headers["x-b3-sampled"] ? headers["x-b3-sampled"] === "1" || headers["x-b3-sampled"] === "true" : true)
@@ -39850,7 +40402,7 @@ const w3c = (headers) => {
 	switch (version) {
 		case "00":
 			if (w3cTraceId.test(traceId) === false || w3cSpanId.test(spanId) === false || traceId === "00000000000000000000000000000000" || spanId === "0000000000000000") return none();
-			return some$1(externalSpan({
+			return some(externalSpan({
 				traceId,
 				spanId,
 				sampled: (parseInt(flags, 16) & 1) === 1
@@ -40943,7 +41495,7 @@ const toString = (self) => {
 */
 var Generator = class extends (/*#__PURE__*/ Service$2()("effect/http/Etag/Generator")) {};
 const fromFileInfo = (info) => {
-	const mtime = match$5(info.mtime, {
+	const mtime = match$6(info.mtime, {
 		onNone: () => "0",
 		onSome: (mtime) => mtime.getTime().toString(16)
 	});
@@ -41292,7 +41844,7 @@ const setHeader = /*#__PURE__*/ dual(3, (self, key, value) => makeResponse(self,
 */
 const removeHeader = /*#__PURE__*/ dual(2, (self, key) => makeResponse({
 	...self,
-	headers: remove$1(self.headers, key)
+	headers: remove$3(self.headers, key)
 }));
 /**
 * Returns a response with all supplied headers set on the existing header map.
@@ -42374,7 +42926,7 @@ const causeResponseStripped = (cause) => {
 		}
 		return true;
 	});
-	return [response ?? internalServerError$1, failures.length > 0 ? some$1(fromReasons(failures)) : none()];
+	return [response ?? internalServerError$1, failures.length > 0 ? some(fromReasons(failures)) : none()];
 };
 const internalServerError$1 = /*#__PURE__*/ empty({ status: 500 });
 const succeedInternalServerError = /*#__PURE__*/ succeed$4(internalServerError$1);
@@ -42810,21 +43362,6 @@ const fromWebSocket = (acquire, options) => withFiber((fiber) => {
 	}));
 });
 const defaultHighWaterMark = 65536;
-// ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/internal/lazyStream.js
-/**
-* Opens `stream` on its first pull rather than when it is run, so a consumer
-* that runs it without pulling, such as a Web `ReadableStream`, leaves the
-* body unread.
-*
-* @internal
-*/
-const openOnFirstPull = (stream) => fromChannel(fromTransform$1((_, scope) => sync(() => {
-	let pull;
-	return suspend$2(() => pull ?? flatMap$1(toPullScoped(stream.channel, scope), (upstream) => {
-		pull = upstream;
-		return upstream;
-	}));
-})));
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/MultipartParser/internal/contentType.js
 /**
 * RegExp to match *( ";" parameter ) in RFC 7231 sec 3.1.1.1
@@ -43548,87 +44085,6 @@ const makeConfig = (headers) => withFiber((fiber) => {
 		isFile: mimeTypes.length === 0 ? void 0 : (info) => !mimeTypes.some((_) => info.contentType.includes(_)) && defaultIsFile(info)
 	});
 });
-/**
-* Creates a channel that parses multipart byte chunks into multipart parts.
-*
-* **Details**
-*
-* The channel consumes non-empty batches of `Uint8Array` chunks and emits
-* non-empty batches of parsed `Part` values, failing with `MultipartError` for
-* parser and limit failures.
-*
-* @stability unstable
-* @category parsing
-* @since 4.0.0
-*/
-const makeChannel = (headers) => fromTransform$1((upstream) => map$2(makeConfig(headers), (config) => {
-	let partsBuffer = [];
-	let exit = none();
-	let ended = false;
-	const parser = make$29({
-		...config,
-		onField(info, value) {
-			partsBuffer.push(new FieldImpl$1(info.name, info.contentType, decodeField(info, value)));
-		},
-		onFile(info) {
-			let chunks = [];
-			let finished = false;
-			const pullChunks = fromPull$1(succeed$4(suspend$2(function loop() {
-				if (!isReadonlyArrayNonEmpty(chunks)) {
-					if (finished) return done();
-					if (isSome(exit)) return exit.value;
-					return flatMap$1(pump, loop);
-				}
-				const chunk = chunks;
-				chunks = [];
-				return succeed$4(chunk);
-			})));
-			partsBuffer.push(new FileImpl$1(info, mapError$1(pullChunks, toMultipartError)));
-			return function(chunk) {
-				if (chunk === null) finished = true;
-				else chunks.push(chunk);
-			};
-		},
-		onError(error_) {
-			exit = some$1(fail$5(convertError$1(error_)));
-		},
-		onDone() {
-			if (isNone(exit)) exit = some$1(fail$5(Done()));
-		}
-	});
-	const pump = upstream.pipe(flatMap$1((chunk) => {
-		for (let i = 0; i < chunk.length; i++) parser.write(chunk[i]);
-		return void_$1;
-	}), catchCause$2((cause) => {
-		if (isDoneCause(cause)) {
-			if (!ended) {
-				ended = true;
-				parser.end();
-			}
-		} else exit = some$1(failCause$5(cause));
-		return void_$1;
-	}));
-	return suspend$2(function loop() {
-		if (!isReadonlyArrayNonEmpty(partsBuffer)) {
-			if (isSome(exit)) return exit.value;
-			return flatMap$1(pump, loop);
-		}
-		const parts = partsBuffer;
-		partsBuffer = [];
-		return succeed$4(parts);
-	});
-}));
-function convertError$1(cause) {
-	switch (cause._tag) {
-		case "ReachedLimit": switch (cause.limit) {
-			case "MaxParts": return MultipartError.fromReason("TooManyParts", cause);
-			case "MaxFieldSize": return MultipartError.fromReason("FieldTooLarge", cause);
-			case "MaxPartSize": return MultipartError.fromReason("FileTooLarge", cause);
-			case "MaxTotalSize": return MultipartError.fromReason("BodyTooLarge", cause);
-		}
-		default: return MultipartError.fromReason("Parse", cause);
-	}
-}
 var PartBase$1 = class extends Class$2 {
 	[TypeId$14];
 	constructor() {
@@ -43636,52 +44092,6 @@ var PartBase$1 = class extends Class$2 {
 		this[TypeId$14] = TypeId$14;
 	}
 };
-var FieldImpl$1 = class extends PartBase$1 {
-	_tag = "Field";
-	key;
-	contentType;
-	value;
-	constructor(key, contentType, value) {
-		super();
-		this.key = key;
-		this.contentType = contentType;
-		this.value = value;
-	}
-	toJSON() {
-		return {
-			_id: "@effect/platform/Multipart/Part",
-			_tag: "Field",
-			key: this.key,
-			contentType: this.contentType,
-			value: this.value
-		};
-	}
-};
-var FileImpl$1 = class extends PartBase$1 {
-	_tag = "File";
-	key;
-	name;
-	contentType;
-	content;
-	contentEffect;
-	constructor(info, channel) {
-		super();
-		this.key = info.name;
-		this.name = info.filename ?? info.name;
-		this.contentType = info.contentType;
-		this.content = fromChannel(channel);
-		this.contentEffect = mkUint8Array$1(channel);
-	}
-	toJSON() {
-		return {
-			_id: "@effect/platform/Multipart/Part",
-			_tag: "File",
-			key: this.key,
-			name: this.name,
-			contentType: this.contentType
-		};
-	}
-};
 const defaultWriteFile = (path, file) => flatMap$1(FileSystem, (fs) => mapError$2(run$1(file.content, fs.sink(path)), toMultipartError));
 const maxPersistedFileNameBytes = 128;
 const fileNameEncoder = /*#__PURE__*/ new TextEncoder();
@@ -43888,149 +44298,11 @@ const toURL = (self) => {
 	const host = self.headers.host ?? "localhost";
 	const protocol = self.protocol ?? (/^https:/i.test(self.originalUrl) ? "https" : "http");
 	try {
-		return some$1(new URL(self.url.startsWith("/") ? `.${self.url}` : self.url, `${protocol}://${host}`));
+		return some(new URL(self.url.startsWith("/") ? `.${self.url}` : self.url, `${protocol}://${host}`));
 	} catch {
 		return none();
 	}
 };
-// ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/internal/decompression.js
-const defaultMaxDecompressedSize = /*#__PURE__*/ mebibytes(10);
-/**
-* Parses a `Content-Encoding` header into the codings to undo, in the order
-* they were applied. `identity` members are dropped. Returns `undefined` if
-* any member is unsupported.
-*
-* @internal
-*/
-const parseContentEncoding = (header) => {
-	const codings = [];
-	for (const member of header.split(",")) {
-		const coding = member.trim().toLowerCase();
-		if (coding === "" || coding === "identity") continue;
-		if (coding !== "gzip" && coding !== "deflate") return void 0;
-		codings.push(coding);
-	}
-	return codings;
-};
-/**
-* Wraps a request so that its body accessors yield the decompressed body.
-* Decompression happens lazily, when a body accessor is read.
-*
-* @internal
-*/
-var DecompressedRequest = class DecompressedRequest extends Class$2 {
-	[TypeId$13];
-	[TypeId$20];
-	inner;
-	codings;
-	maxDecompressedSize;
-	headers;
-	constructor(inner, codings, maxDecompressedSize) {
-		super();
-		this[TypeId$13] = TypeId$13;
-		this[TypeId$20] = TypeId$20;
-		this.inner = inner;
-		this.codings = codings;
-		this.maxDecompressedSize = maxDecompressedSize;
-		this.headers = removeMany(inner.headers, ["content-encoding", "content-length"]);
-	}
-	toJSON() {
-		return inspect(this, {
-			_id: "HttpServerRequest",
-			method: this.method,
-			url: this.originalUrl
-		});
-	}
-	modify(options) {
-		return new DecompressedRequest(this.inner.modify(options), this.codings, this.maxDecompressedSize);
-	}
-	get source() {
-		return this.inner.source;
-	}
-	get url() {
-		return this.inner.url;
-	}
-	get originalUrl() {
-		return this.inner.originalUrl;
-	}
-	get method() {
-		return this.inner.method;
-	}
-	get cookies() {
-		return this.inner.cookies;
-	}
-	get remoteAddress() {
-		return this.inner.remoteAddress;
-	}
-	get peerAddress() {
-		return this.inner.peerAddress;
-	}
-	get protocol() {
-		return this.inner.protocol;
-	}
-	get upgrade() {
-		return this.inner.upgrade;
-	}
-	get response() {
-		return this.inner.response;
-	}
-	get stream() {
-		return openOnFirstPull(unwrap$2(withFiber((fiber) => {
-			const limit = this.maxDecompressedSize ?? fiber.getRef(MaxBodySize) ?? defaultMaxDecompressedSize;
-			return succeed$4(fromReadableStream({
-				evaluate: () => {
-					let body = toReadableStreamWith(this.inner.stream, fiber.context);
-					for (let i = this.codings.length - 1; i >= 0; i--) body = body.pipeThrough(new DecompressionStream(this.codings[i]));
-					let size = 0;
-					return body.pipeThrough(new TransformStream({ transform: (chunk, controller) => {
-						size += chunk.byteLength;
-						if (size > limit) controller.error(this.parseError(void 0, `Decompressed request body exceeds ${limit} bytes`, "BodyTooLarge"));
-						else controller.enqueue(chunk);
-					} }));
-				},
-				onError: (cause) => cause instanceof HttpServerError ? cause : this.parseError(cause)
-			}));
-		})));
-	}
-	bytesEffect;
-	get bytes() {
-		return this.bytesEffect ??= runSync$1(cached(mkUint8Array(this.stream)));
-	}
-	get text() {
-		return map$2(this.bytes, (bytes) => textDecoder$1.decode(bytes));
-	}
-	get json() {
-		return flatMap$1(this.text, (text) => try_({
-			try: () => text === "" ? null : JSON.parse(text),
-			catch: (cause) => this.parseError(cause)
-		}));
-	}
-	get urlParamsBody() {
-		return flatMap$1(this.text, (text) => try_({
-			try: () => fromInput(new URLSearchParams(text)),
-			catch: (cause) => this.parseError(cause)
-		}));
-	}
-	get arrayBuffer() {
-		return map$2(this.bytes, (bytes) => bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength));
-	}
-	get multipartStream() {
-		return pipeThroughChannel(mapError(this.stream, (cause) => MultipartError.fromReason(cause.reason instanceof RequestParseError && cause.reason.request === this ? cause.reason.reason ?? "Parse" : "InternalError", cause)), makeChannel(this.headers));
-	}
-	multipartEffect;
-	get multipart() {
-		return this.multipartEffect ??= runSync$1(cached(toPersisted(this.multipartStream)));
-	}
-	parseError(cause, description, reason = "Parse") {
-		return new HttpServerError({ reason: new RequestParseError({
-			request: this,
-			reason,
-			...description === void 0 ? void 0 : { description },
-			...cause === void 0 ? void 0 : { cause }
-		}) });
-	}
-};
-const textDecoder$1 = /*#__PURE__*/ new TextDecoder();
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/internal/requestState.js
 /**
 * Mutable state owned by the root that handles a single server request.
@@ -44059,19 +44331,6 @@ const appendPreResponseHandlerUnsafe$1 = (context, handler) => {
 };
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/HttpMiddleware.js
 /**
-* Wraps HTTP server apps with request and response behavior.
-*
-* A middleware is a function from one HTTP server app effect to another. The app
-* runs with the current `HttpServerRequest` in its context, so middleware can
-* inspect or rewrite the request, provide request-scoped services, attach hooks
-* before the response is sent, or observe the app exit. This module includes
-* middleware for response logging, server tracing, forwarded proxy headers,
-* parsed search parameters, and CORS response headers.
-*
-* @stability unstable
-* @since 4.0.0
-*/
-/**
 * Defines an `HttpMiddleware` while preserving its precise type.
 *
 * **Gotchas**
@@ -44362,60 +44621,6 @@ const cors$1 = (options) => {
 		return httpApp;
 	});
 };
-/**
-* Middleware that decompresses request bodies sent with a `Content-Encoding`
-* of `gzip` or `deflate`.
-*
-* **Details**
-*
-* The request service is replaced with a view whose body accessors (`stream`,
-* `text`, `json`, `arrayBuffer`, `urlParamsBody`, `multipart`) yield the
-* decompressed body, and whose headers no longer include `Content-Encoding`
-* or `Content-Length`. Decompression is lazy and only happens when the body
-* is read. Stacked codings such as `deflate, gzip` are undone in reverse
-* order, and `identity` members are ignored.
-*
-* Requests whose `Content-Encoding` includes any other coding are rejected
-* with `415 Unsupported Media Type` and `Accept-Encoding: gzip, deflate`,
-* without running the app. Malformed compressed data fails the body read
-* with a `RequestParseError`, or a `MultipartError` with reason `Parse` when
-* reading multipart data.
-*
-* The decompressed size is limited to `maxDecompressedSize`, falling back to
-* the `MaxBodySize` reference and then to 10 MiB. Exceeding it fails the body
-* read with a `RequestParseError`, or a `MultipartError` with reason
-* `BodyTooLarge` when reading multipart data. The limit applies to every body
-* accessor, including `stream`.
-*
-* Decompression uses the global `DecompressionStream`. `deflate` means the
-* zlib format (RFC 1950); raw deflate data is rejected.
-*
-* **Gotchas**
-*
-* `request.source` is still the original, compressed request.
-* `HttpServerRequest.toWeb` returns that compressed request only when the
-* source is a Web `Request`. On other platforms, such as Node, it builds a new
-* `Request` from the decompressed body and the stripped headers.
-*
-* @stability unstable
-* @category compression
-* @since 4.0.0
-*/
-const decompression = (options) => {
-	const maxDecompressedSize = options?.maxDecompressedSize === void 0 ? void 0 : fromInputUnsafe(options.maxDecompressedSize);
-	return (httpApp) => withFiber((fiber) => {
-		const request = getUnsafe$2(fiber.context, HttpServerRequest);
-		const contentEncoding = request.headers["content-encoding"];
-		if (contentEncoding === void 0 || !hasBody(request.method)) return httpApp;
-		const codings = parseContentEncoding(contentEncoding);
-		if (codings === void 0) return succeed$4(empty({
-			status: 415,
-			headers: { "accept-encoding": "gzip, deflate" }
-		}));
-		if (codings.length === 0) return httpApp;
-		return provideService(httpApp, HttpServerRequest, new DecompressedRequest(request, codings, maxDecompressedSize));
-	});
-};
 // ../../node_modules/.pnpm/effect@4.0.6/node_modules/effect/dist/http/HttpEffect.js
 /**
 * Runs an HTTP server effect, sends the produced response with the supplied handler, and converts failures into HTTP responses.
@@ -44886,7 +45091,7 @@ const RouteTypeId = "~effect/http/HttpRouter/Route";
 const makeRoute = (options) => ({
 	...options,
 	uninterruptible: options.uninterruptible ?? false,
-	prefix: typeof options.prefix === "string" ? some$1(options.prefix) : options.prefix ?? none(),
+	prefix: typeof options.prefix === "string" ? some(options.prefix) : options.prefix ?? none(),
 	[RouteTypeId]: RouteTypeId
 });
 /**
@@ -44944,7 +45149,7 @@ const prefixPath = /*#__PURE__*/ dual(2, (self, prefix) => {
 const prefixRoute = /*#__PURE__*/ dual(2, (self, prefix) => makeRoute({
 	...self,
 	path: prefixPath(self.path, prefix),
-	prefix: match$5(self.prefix, {
+	prefix: match$6(self.prefix, {
 		onNone: () => removeTrailingSlash(prefix),
 		onSome: (existingPrefix) => prefixPath(existingPrefix, prefix)
 	})
@@ -45205,7 +45410,7 @@ function isStreamSchema(schema) {
 * @internal
 */
 function getStreamSchemas(schema) {
-	return isStreamSchema(schema) ? some$1({
+	return isStreamSchema(schema) ? some({
 		success: schema.success,
 		error: schema.error
 	}) : none();
@@ -52144,10 +52349,10 @@ const makeFile = /*#__PURE__*/ (() => {
 					}), (bytesRead) => {
 						if (bytesRead === 0) return none();
 						if (explicit === void 0) this.position = position + BigInt(bytesRead);
-						if (bytesRead === size) return some$1(buffer);
+						if (bytesRead === size) return some(buffer);
 						const dst = Buffer.allocUnsafeSlow(bytesRead);
 						buffer.copy(dst, 0, 0, bytesRead);
-						return some$1(dst);
+						return some(dst);
 					});
 				} catch (cause) {
 					return fail$3(handleBadArgument("readAlloc")(cause));
@@ -52249,7 +52454,7 @@ const makeFileInfo = (stat, method = "stat") => try_({
 		uid: bigintToNumberOption(stat.uid),
 		gid: bigintToNumberOption(stat.gid),
 		size: bytes(stat.size),
-		blksize: stat.blksize !== void 0 ? some$1(bytes(stat.blksize)) : none(),
+		blksize: stat.blksize !== void 0 ? some(bytes(stat.blksize)) : none(),
 		blocks: fromNullishOr(stat.blocks)
 	}),
 	catch: handleBadArgument(method)
@@ -52566,7 +52771,7 @@ const layer$11 = /*#__PURE__*/ layerMergedContext(/*#__PURE__*/ succeed$4(/* @__
 	const fetch = fiber.getRef(Fetch);
 	const options = getOrUndefined(fiber.context, RequestInit) ?? {};
 	let headers = options.headers ? merge(fromInput$1(options.headers), request.headers) : request.headers;
-	if (headers["content-length"]) headers = remove$1(headers, "content-length");
+	if (headers["content-length"]) headers = remove$3(headers, "content-length");
 	let uploadController;
 	const stopUpload = sync(() => uploadController?.abort());
 	const send = (body) => map$2(tryPromise({
@@ -53340,7 +53545,7 @@ const layer$5 = /*#__PURE__*/ effect(Terminal, /*#__PURE__*/ (/* @__PURE__ */ fn
 		}
 		return queue;
 	});
-	const readLine = suspend$2(() => poll(lines).pipe(flatMap$1(match$5({
+	const readLine = suspend$2(() => poll(lines).pipe(flatMap$1(match$6({
 		onNone: () => scoped(andThen(get$4(rlRef), take(lines))),
 		onSome: succeed$4
 	})), mapError$2(() => new QuitError({}))));
@@ -55133,7 +55338,7 @@ const toSchemaStore = (self, schema) => {
 	const modify = (key, f) => flatMap$1(get(key), (o) => {
 		if (isNone(o)) return succeedNone;
 		const newValue = f(o.value);
-		return as(set(key, newValue), some$1(newValue));
+		return as(set(key, newValue), some(newValue));
 	});
 	return {
 		[SchemaStoreTypeId]: SchemaStoreTypeId,
@@ -63931,7 +64136,7 @@ const runWithRuntime = /*#__PURE__*/ fnUntraced(function* (options, runtime, tra
 				const request = request_;
 				const httpRequest = isHttp ? getOrUndefined(fiber.context, HttpServerRequest) : void 0;
 				if (httpRequest !== void 0 && request._tag !== "Eof") appendPreResponseHandlerUnsafe(fiber.context, (_, response) => succeed$4(response.status === 200 && response.body._tag === "Uint8Array" && response.body.contentLength === 0 ? empty({
-					headers: remove$1(response.headers, "content-type"),
+					headers: remove$3(response.headers, "content-type"),
 					status: 202
 				}) : response));
 				switch (request._tag) {
@@ -64307,7 +64512,7 @@ const toServerSentEvents = (response, keepAlive) => {
 	const options = {
 		status: response.status,
 		statusText: response.statusText,
-		headers: remove$1(response.headers, "content-type"),
+		headers: remove$3(response.headers, "content-type"),
 		cookies: response.cookies,
 		contentType: "text/event-stream"
 	};
@@ -64853,7 +65058,7 @@ const unavailable = text("The authorization service is temporarily unavailable;
 	status: 503
 });
 var Auth = class Auth extends Service$2()("@deslop/runtime/auth/service/Auth") {
-	static makeContext = (auth) => pipe(make$71(Auth, auth), add$3(RpcAuth, RpcAuth.of((effect, request) => pipe(auth.user(request.headers), flatMap$1((user) => provideService(effect, CurrentUser, user))))));
+	static makeContext = (auth) => pipe(make$71(Auth, auth), add$3(RpcAuth, RpcAuth.of((effect, request) => pipe(auth.user(request.headers), flatMap$1((user) => raceFirst(provideService(effect, CurrentUser, user), pipe(delay(auth.user(request.headers), "5 minutes"), retry({ while: (error) => error.error === "temporarily_unavailable" }), forever)))))));
 	static layer = (resource) => effectContext(gen(function* () {
 		const url = yield* pipe(String$1("AUTH_URL"), withDefault(AUTH_URL));
 		const client = filterStatusOk(yield* HttpClient);
@@ -64973,7 +65178,7 @@ const layerNodeHttpServer = layerConfig(createServer, {
 	port: pipe(Port("PORT"), withDefault(5e3))
 });
 // package.json
-var version = "0.1.1142";
+var version = "0.1.1155";
 // src/services/telemetry/schema.ts
 var TelemetryError = class extends TaggedError()("TelemetryError", {
 	cause: optional$6(Defect()),
@@ -65053,6 +65258,12 @@ const Entry = Struct({
 	time: Nano,
 	traceId: String$2
 });
+const EntryItem = Entry.mapFields(omit([
+	"resource",
+	"resourceSchemaUrl",
+	"scope",
+	"scopeSchemaUrl"
+]));
 const Query = Struct({
 	errors: Boolean$2,
 	from: Finite,
@@ -65070,7 +65281,7 @@ const Query = Struct({
 	traceId: String$2
 });
 const Page = Struct({
-	entries: ArraySchema(Entry),
+	entries: ArraySchema(EntryItem),
 	total: Int
 });
 const Runtime = Literals([
@@ -65128,9 +65339,9 @@ const Stats = Struct({
 	to: Finite
 });
 const TraceSpan = Struct({
-	...Entry.fields,
+	...EntryItem.fields,
 	depth: Natural,
-	logs: ArraySchema(Entry),
+	logs: ArraySchema(EntryItem),
 	offsetMs: Finite,
 	parentSpanId: String$2,
 	runtime: Runtime
@@ -65138,7 +65349,7 @@ const TraceSpan = Struct({
 const Trace = Struct({
 	durationMs: Finite,
 	id: TraceId,
-	logs: ArraySchema(Entry),
+	logs: ArraySchema(EntryItem),
 	services: ArraySchema(Service),
 	spans: ArraySchema(TraceSpan)
 });
@@ -65153,7 +65364,7 @@ const Filters = Struct({
 });
 const PageFilters = Struct({
 	...Filters.fields,
-	limit: pipe(Query.fields.limit, withDecodingDefaultTypeKey(succeed$4(100)), annotateEncoded({ description: "Page size, 1 to 1000." })),
+	limit: pipe(Query.fields.limit, withDecodingDefaultTypeKey(succeed$4(20)), annotateEncoded({ description: "Page size, 1 to 1000." })),
 	offset: pipe(Query.fields.offset, withDecodingDefaultTypeKey(succeed$4(0)), annotateEncoded({ description: "Entries to skip, for the next page." }))
 });
 const SortFilters = Struct({
@@ -65177,28 +65388,35 @@ function started(resource) {
 	if (is$2(Nano)(value)) return BigInt(value);
 	return 0n;
 }
-function latestEntry(entries) {
+function runsOf(entries) {
+	const runs = fromEntries(map$5(entries, (entry) => [entry.id, started(entry.resource)]));
+	return (entry) => runs[entry.id] ?? 0n;
+}
+function latestEntry(entries, run) {
 	return reduce(entries, headNonEmpty(entries), (current, entry) => {
-		if (started(entry.resource) > started(current.resource)) return entry;
+		if (run(entry) > run(current)) return entry;
 		return current;
 	});
 }
 function currentEntries(entries) {
-	const latest = map$6(groupBy(entries, (entry) => entry.service), (group) => started(latestEntry(group).resource));
-	const stale = fromIterable(map$5(filter$1(entries, (entry) => entry.traceId !== "" && started(entry.resource) < (latest[entry.service] ?? 0n)), (entry) => entry.traceId));
-	return filter$1(entries, (entry) => started(entry.resource) === (latest[entry.service] ?? 0n) && !has(stale, entry.traceId));
+	const run = runsOf(entries);
+	const latest = map$6(groupBy(entries, (entry) => entry.service), (group) => run(latestEntry(group, run)));
+	const stale = fromIterable(map$5(filter$1(entries, (entry) => entry.traceId !== "" && run(entry) < (latest[entry.service] ?? 0n)), (entry) => entry.traceId));
+	return filter$1(entries, (entry) => run(entry) === (latest[entry.service] ?? 0n) && !has(stale, entry.traceId));
 }
 function serviceName(resource) {
 	const value = resourceString(resource, "service.name");
 	if (isNonEmpty$1(value)) return value;
 	return "unknown";
 }
-function displayValue(value) {
-	return JSON.stringify(value, void 0, 2);
+function leaves(value) {
+	if (isArray(value)) return flatMap$4(value, leaves);
+	if (isString$1(value) || isNumber(value) || isBoolean(value)) return [`${value}`];
+	if (value === null) return [];
+	return flatMap$4(values$2(value), leaves);
 }
 function logMessage(body) {
-	if (isString$1(body["stringValue"])) return body["stringValue"];
-	return displayValue(body);
+	return join$1(leaves(body), " ");
 }
 function durationMs(start, end) {
 	if (BigInt(end) < BigInt(start)) return 0;
@@ -65220,9 +65438,16 @@ function summary(entries, query) {
 	};
 }
 function filterEntries(entries, query, signal) {
+	const text = toLowerCase(query.text);
+	const traceId = toLowerCase(query.traceId);
 	return filter$1(entries, (entry) => {
 		const milliseconds = pipe(parse$2(`${BigInt(entry.time) / 1000000n}`), getOrThrow$1);
-		return (signal === "all" || entry.signal === signal) && milliseconds >= query.from && milliseconds <= query.to && (query.service === "" || entry.service === query.service) && (query.operation === "" || entry.name === query.operation) && (query.traceId === "" || entry.traceId === toLowerCase(query.traceId)) && (!query.errors || entry.status === 2) && includes(toLowerCase(query.text))(toLowerCase(displayValue(entry)));
+		return (signal === "all" || entry.signal === signal) && milliseconds >= query.from && milliseconds <= query.to && (query.service === "" || entry.service === query.service) && (query.operation === "" || entry.name === query.operation) && (traceId === "" || entry.traceId === traceId) && (!query.errors || entry.status === 2) && (text === "" || includes(text)(toLowerCase(join$1([entry.name, ...leaves(pick(entry.payload, [
+			"attributes",
+			"body",
+			"events",
+			"status"
+		]))], " "))));
 	});
 }
 function orderEntries(entries, sort$1) {
@@ -65232,10 +65457,11 @@ function orderEntries(entries, sort$1) {
 	}));
 }
 function serviceStatuses(entries) {
+	const runOf = runsOf(entries);
 	return collect$1(groupBy(entries, (entry) => entry.service), (name, group) => {
-		const latest = latestEntry(group);
-		const run = started(latest.resource);
-		const current = filter$1(group, (entry) => started(entry.resource) === run);
+		const latest = latestEntry(group, runOf);
+		const run = runOf(latest);
+		const current = filter$1(group, (entry) => runOf(entry) === run);
 		return {
 			entries: current.length,
 			lastEventAt: reduce(current, "0", (time, entry) => {
@@ -65248,6 +65474,20 @@ function serviceStatuses(entries) {
 		};
 	});
 }
+function traceTiming(records) {
+	const spans = filter$1(records, (entry) => entry.signal === "trace");
+	const start = match$3(match$3(spans, {
+		onEmpty: () => records,
+		onNonEmpty: identity
+	}), {
+		onEmpty: () => "0",
+		onNonEmpty: (timed) => min(map$5(timed, (entry) => entry.time), mapInput(BigInt$5, (time) => BigInt(time)))
+	});
+	return {
+		durationMs: reduce(spans, 0, (end, span) => max(end, durationMs(start, span.time) + span.durationMs)),
+		time: start
+	};
+}
 function parentId(entry) {
 	if (isString$1(entry.payload["parentSpanId"])) return toLowerCase(entry.payload["parentSpanId"]);
 	return "";
@@ -65259,13 +65499,10 @@ function traceView(entries, id) {
 		index
 	}));
 	const byId = fromEntries(map$5(spans, (span) => [span.entry.spanId, span]));
-	const start = pipe(head(map$5(spans, (span) => span.entry)), orElse$2(() => head(ordered)), match$5({
-		onNone: () => "0",
-		onSome: (entry) => entry.time
-	}));
+	const timing = traceTiming(entries);
 	const logs = filter$1(ordered, (entry) => entry.signal === "log");
 	const bySpan = groupBy(logs, (log) => log.spanId);
-	const nodes = map$5(spans, (span) => {
+	const tree = pipe(map$5(spans, (span) => {
 		const ancestors = reverse(unfold({
 			entry: span.entry,
 			seen: make$44(span.entry.spanId)
@@ -65279,15 +65516,14 @@ function traceView(entries, id) {
 				...span.entry,
 				depth: ancestors.length,
 				logs: getOrElse(get$9(bySpan, span.entry.spanId), () => []),
-				offsetMs: durationMs(start, span.entry.time),
+				offsetMs: durationMs(timing.time, span.entry.time),
 				parentSpanId: parentId(span.entry),
 				runtime: runtime(span.entry.resource)
 			}
 		};
-	});
-	const tree = pipe(nodes, sort(Struct$1({ path: Array_(Number$5) })), map$5((node) => node.value));
+	}), sort(Struct$1({ path: Array_(Number$5) })), map$5((node) => node.value));
 	return {
-		durationMs: reduce(nodes, 0, (end, node) => max(end, node.value.offsetMs + node.value.durationMs)),
+		durationMs: timing.durationMs,
 		id,
 		logs: filter$1(logs, (log) => !has$3(byId, log.spanId)),
 		services: dedupeWith(map$5([...tree, ...logs], (entry) => ({
@@ -65298,18 +65534,35 @@ function traceView(entries, id) {
 	};
 }
 // src/services/telemetry/service.ts
+const RETENTION = days(3);
 const failed = mapError$2((cause) => TelemetryError.make({
 	cause,
 	message: "The telemetry storage could not be read or written."
 }));
 var Telemetry = class extends Service$2()("@deslop/scope/services/telemetry/service/Telemetry", { make: fnUntraced(function* (directory) {
 	const fs = yield* FileSystem;
+	const path = yield* Path$1;
 	const store = toSchemaStore(yield* KeyValueStore, Entry);
 	const crypto = yield* Crypto;
 	const since = yield* currentTimeMillis;
 	const rejections = yield* make$48(empty$11());
-	const saved = yield* forEach$1(filter$1(yield* fs.readDirectory(directory), (file) => !endsWith(".tmp")(file)), (file) => flatMap$1(try_(() => decodeURIComponent(file)), (key) => store.get(key)), { concurrency: 8 });
+	const saved = yield* forEach$1(yield* fs.readDirectory(directory), (file) => pipe(try_(() => decodeURIComponent(file)), filterOrFail((key) => !endsWith(".tmp")(key)), flatMap$1((key) => store.get(key)), catch_$2(() => as(fs.remove(path.join(directory, file), { force: true }), none()))), { concurrency: 8 });
 	const state = yield* make$9(fromIterable$2(map$5(getSomes(saved), (entry) => [entry.id, entry])));
+	const prune = gen(function* () {
+		const cutoff = BigInt((yield* currentTimeMillis) - toMillis(RETENTION)) * 1000000n;
+		yield* updateEffect(state, (current) => {
+			const expired = filter$1(fromIterable$6(values(current)), (entry) => BigInt(entry.time) < cutoff);
+			return as(forEach$1(expired, (entry) => store.remove(entry.id), {
+				concurrency: 1,
+				discard: true
+			}), reduce(expired, current, (all, entry) => remove$1(all, entry.id)));
+		});
+	});
+	yield* prune;
+	yield* pipe(prune, ignore$1({
+		log: "Warn",
+		message: "Expired telemetry could not be deleted"
+	}), repeat(spaced("1 hour")), forkScoped);
 	const read = map$2(get(state), (entries) => fromIterable$6(values(entries)));
 	const selected = fnUntraced(function* (runs) {
 		const entries = yield* read;
@@ -65400,36 +65653,37 @@ var Telemetry = class extends Service$2()("@deslop/scope/services/telemetry/serv
 			return summary(filterEntries(yield* selected(query.runs), query, "trace"), query);
 		}),
 		trace: fn("Telemetry.trace")(function* (id) {
-			const entries = yield* read;
-			if (!some(entries, (entry) => entry.traceId === toLowerCase(id))) return yield* TelemetryError.make({ message: "No telemetry received for this trace." });
-			return traceView(filter$1(entries, (entry) => entry.traceId === toLowerCase(id)), id);
+			const traceId = toLowerCase(id);
+			const records = filter$1(yield* read, (entry) => entry.traceId === traceId);
+			if (isReadonlyArrayEmpty(records)) return yield* TelemetryError.make({ message: "No telemetry received for this trace." });
+			return traceView(records, traceId);
 		}),
 		traces: fn("Telemetry.traces")(function* (query) {
 			const active = yield* selected(query.runs);
 			const byTrace = groupBy(active, (entry) => entry.traceId);
-			const entries = map$5(dedupe(map$5(filter$1(filterEntries(active, query, "all"), (entry) => entry.traceId !== ""), (entry) => entry.traceId)), (id) => {
-				const records = byTrace[id] ?? [];
-				const view = traceView(records, id);
-				const root = getOrElse(head(view.spans), () => getOrThrow$1(head(records)));
-				return {
-					durationMs: view.durationMs,
-					errors: countBy(records, (entry) => entry.status === 2),
-					id,
-					logs: countBy(records, (entry) => entry.signal === "log"),
-					operation: root.name,
-					service: root.service,
-					services: view.services,
-					spans: view.spans.length,
-					time: root.time
-				};
-			});
-			const sorted = sort(entries, match$1(query.sort === "slowest", {
-				onFalse: () => flip$2(mapInput(BigInt$5, (entry) => BigInt(entry.time))),
-				onTrue: () => flip$2(mapInput(Number$5, (entry) => entry.durationMs))
-			}));
+			const ids = dedupe(map$5(filter$1(filterEntries(active, query, "all"), (entry) => entry.traceId !== ""), (entry) => entry.traceId));
+			const ordered = orderEntries(map$5(ids, (id) => ({
+				id,
+				...traceTiming(byTrace[id] ?? [])
+			})), query.sort);
 			return {
-				entries: take$3(drop$1(sorted, query.offset), query.limit),
-				total: entries.length
+				entries: map$5(take$3(drop$1(ordered, query.offset), query.limit), (found) => {
+					const records = byTrace[found.id] ?? [];
+					const view = traceView(records, found.id);
+					const root = getOrElse(head(view.spans), () => getOrThrow$1(head(records)));
+					return {
+						durationMs: found.durationMs,
+						errors: countBy(records, (entry) => entry.status === 2),
+						id: found.id,
+						logs: countBy(records, (entry) => entry.signal === "log"),
+						operation: root.name,
+						service: root.service,
+						services: view.services,
+						spans: view.spans.length,
+						time: found.time
+					};
+				}),
+				total: ids.length
 			};
 		})
 	};
@@ -65438,7 +65692,7 @@ var Telemetry = class extends Service$2()("@deslop/scope/services/telemetry/serv
 };
 // src/tools/contracts.ts
 const Tools = make$6(make$7("list_services", {
-	description: "Check ingestion first: every stored service, its runtime, latest run, last event time and entry count. Event/run times use the exporter clock (Unix nanoseconds), not receiver arrival time. Rejected OTLP requests are grouped by route, HTTP status and credential-header presence, never attributed to an app. Rejection counters and since (Unix milliseconds) reset when Scope restarts. Missing services have never sent retained telemetry.",
+	description: "Check ingestion first: every stored service, its runtime, latest run, last event time and entry count. Event/run times use the exporter clock (Unix nanoseconds), not receiver arrival time. Rejected OTLP requests are grouped by route, HTTP status and credential-header presence, never attributed to an app. Rejection counters and since (Unix milliseconds) reset when Scope restarts. Missing services sent no telemetry in the last three days.",
 	failure: TelemetryError,
 	success: IngestionStatus
 }).annotate(Readonly, true), make$7("find_traces", {
@@ -65491,12 +65745,10 @@ const ToolHandlers = Tools.toLayer(gen(function* () {
 	});
 }));
 // src/main.server.ts
-const receiver = use((router) => gen(function* () {
-	const telemetry = yield* Telemetry;
-	const ack = text("{}", { contentType: "application/json" });
-	yield* router.add("POST", "/v1/traces", (request) => {
+function ingest(schema, save) {
+	return (request) => {
 		if (!startsWith("application/json")(request.headers["content-type"] ?? "")) return succeed$4(empty({ status: 415 }));
-		return pipe(schemaBodyJson(TracesRequest), flatMap$1((payload) => telemetry.ingestTraces(payload)), as(ack), catchTags({
+		return pipe(schemaBodyJson(schema), flatMap$1(save), as(text("{}", { contentType: "application/json" })), catchTags({
 			HttpServerError: () => succeed$4(jsonUnsafe({
 				code: 3,
 				message: "Invalid OTLP JSON body"
@@ -65510,27 +65762,15 @@ const receiver = use((router) => gen(function* () {
 				message: "Telemetry storage unavailable"
 			}, { status: 503 }))
 		}));
-	});
-	yield* router.add("POST", "/v1/logs", (request) => {
-		if (!startsWith("application/json")(request.headers["content-type"] ?? "")) return succeed$4(empty({ status: 415 }));
-		return pipe(schemaBodyJson(LogsRequest), flatMap$1((payload) => telemetry.ingestLogs(payload)), as(ack), catchTags({
-			HttpServerError: () => succeed$4(jsonUnsafe({
-				code: 3,
-				message: "Invalid OTLP JSON body"
-			}, { status: 400 })),
-			SchemaError: (error) => succeed$4(jsonUnsafe({
-				code: 3,
-				message: error.message
-			}, { status: 400 })),
-			TelemetryError: () => succeed$4(jsonUnsafe({
-				code: 14,
-				message: "Telemetry storage unavailable"
-			}, { status: 503 }))
-		}));
-	});
+	};
+}
+const receiver = use((router) => gen(function* () {
+	const telemetry = yield* Telemetry;
+	yield* router.add("POST", "/v1/traces", ingest(TracesRequest, telemetry.ingestTraces));
+	yield* router.add("POST", "/v1/logs", ingest(LogsRequest, telemetry.ingestLogs));
 	yield* router.add("GET", "/health", text("ready"));
 }));
-const observe = make$28((app) => pipe(app, decompression(), onExit$1((exit) => gen(function* () {
+const observe = make$28((app) => pipe(app, onExit$1((exit) => gen(function* () {
 	const request = yield* HttpServerRequest;
 	const route = headNonEmpty(split(request.url, "?"));
 	const status = exitResponse(exit).status;
@@ -65556,14 +65796,6 @@ const telemetry = unwrap$5(gen(function* () {
 	const path = yield* Path$1;
 	const directory = path.join(yield* String$1("HOME"), ".deslop", "scope");
 	yield* fs.makeDirectory(directory, { recursive: true });
-	yield* forEach$1([
-		"telemetry.sqlite",
-		"telemetry.sqlite-wal",
-		"telemetry.sqlite-shm"
-	], (name) => fs.remove(path.join(directory, name), { force: true }), {
-		concurrency: 1,
-		discard: true
-	});
 	return Telemetry.layer(path.join(directory, "entries"));
 }));
 runMain(pipe(merge$3(pipe(serve(mergeAll$1(pipe(fresh(receiver), provide$2(HttpAuth.layer)), mcp, cors({