@athrio/loom 0.0.4 → 0.0.5

package/dist/{LoomStore-DMf2PkfP.js → LoomStore-CxUQqaPK.js}

@@ -3829,8 +3829,8 @@ var Combiner_exports = /* @__PURE__ */ __exportAll({
 	intercalate: () => intercalate,
 	last: () => last$3,
 	make: () => make$74,
-	max: () => max$9,
-	min: () => min$9
+	max: () => max$10,
+	min: () => min$10
 });
 /**
 * Creates a `Combiner` from a binary function.
@@ -3926,7 +3926,7 @@ function flip$6(combiner) {
 * @category constructors
 * @since 4.0.0
 */
-function min$9(order) {
+function min$10(order) {
 	return make$74((self, that) => order(self, that) === -1 ? self : that);
 }
 /**
@@ -3961,7 +3961,7 @@ function min$9(order) {
 * @category constructors
 * @since 4.0.0
 */
-function max$9(order) {
+function max$10(order) {
 	return make$74((self, that) => order(self, that) === 1 ? self : that);
 }
 /**
@@ -5343,8 +5343,8 @@ var Order_exports = /* @__PURE__ */ __exportAll({
 	make: () => make$73,
 	makeReducer: () => makeReducer$5,
 	mapInput: () => mapInput$4,
-	max: () => max$8,
-	min: () => min$8
+	max: () => max$9,
+	min: () => min$9
 });
 /**
 * Creates a new `Order` instance from a comparison function.
@@ -5979,7 +5979,7 @@ var isGreaterThanOrEqualTo$8 = (O) => dual(2, (self, that) => O(self, that) !==
 * @category comparisons
 * @since 2.0.0
 */
-var min$8 = (O) => dual(2, (self, that) => self === that || O(self, that) < 1 ? self : that);
+var min$9 = (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.
 *
@@ -6010,7 +6010,7 @@ var min$8 = (O) => dual(2, (self, that) => self === that || O(self, that) < 1 ?
 * @category comparisons
 * @since 2.0.0
 */
-var max$8 = (O) => dual(2, (self, that) => self === that || O(self, that) > -1 ? self : that);
+var max$9 = (O) => dual(2, (self, that) => self === that || O(self, that) > -1 ? self : that);
 /**
 * Restricts a value between a minimum and a maximum according to the given order.
 *
@@ -6044,7 +6044,7 @@ var max$8 = (O) => dual(2, (self, that) => self === that || O(self, that) > -1 ?
 * @category comparisons
 * @since 2.0.0
 */
-var clamp$7 = (O) => dual(2, (self, options) => min$8(O)(options.maximum, max$8(O)(options.minimum, self)));
+var clamp$7 = (O) => dual(2, (self, options) => min$9(O)(options.maximum, max$9(O)(options.minimum, self)));
 /**
 * Checks whether a value is between a minimum and a maximum (inclusive) according to the given order.
 *
@@ -10209,15 +10209,15 @@ var Iterable_exports = /* @__PURE__ */ __exportAll({
 	prepend: () => prepend$5,
 	prependAll: () => prependAll$4,
 	range: () => range$3,
-	reduce: () => reduce$13,
+	reduce: () => reduce$12,
 	repeat: () => repeat$5,
 	replicate: () => replicate$3,
 	scan: () => scan$3,
 	size: () => size$22,
 	some: () => some$12,
-	take: () => take$13,
+	take: () => take$12,
 	takeWhile: () => takeWhile$4,
-	unfold: () => unfold$3,
+	unfold: () => unfold$2,
 	zip: () => zip$6,
 	zipWith: () => zipWith$6
 });
@@ -10722,7 +10722,7 @@ var headUnsafe$1 = (self) => {
 * @category getters
 * @since 2.0.0
 */
-var take$13 = /*#__PURE__*/ dual(2, (self, n) => ({ [Symbol.iterator]() {
+var take$12 = /*#__PURE__*/ dual(2, (self, n) => ({ [Symbol.iterator]() {
 	let i = 0;
 	const iterator = self[Symbol.iterator]();
 	return { next() {
@@ -12059,7 +12059,7 @@ var some$12 = /*#__PURE__*/ dual(2, (self, predicate) => {
 * @category constructors
 * @since 2.0.0
 */
-var unfold$3 = (b, f) => ({ [Symbol.iterator]() {
+var unfold$2 = (b, f) => ({ [Symbol.iterator]() {
 	let next = b;
 	return { next() {
 		const ab = f(next);
@@ -12168,7 +12168,7 @@ var forEach$11 = /*#__PURE__*/ dual(2, (self, f) => {
 * @category folding
 * @since 2.0.0
 */
-var reduce$13 = /*#__PURE__*/ dual(3, (self, b, f) => {
+var reduce$12 = /*#__PURE__*/ dual(3, (self, b, f) => {
 	if (Array.isArray(self)) return self.reduce(f, b);
 	let i = 0;
 	let result = b;
@@ -12439,7 +12439,7 @@ var Record_exports = /* @__PURE__ */ __exportAll({
 	modify: () => modify$15,
 	partition: () => partition$5,
 	pop: () => pop,
-	reduce: () => reduce$12,
+	reduce: () => reduce$11,
 	remove: () => remove$15,
 	replace: () => replace$3,
 	separate: () => separate$2,
@@ -13181,7 +13181,7 @@ var isSubrecord = /*#__PURE__*/ isSubrecordBy(/*#__PURE__*/ asEquivalence());
 * @category folding
 * @since 2.0.0
 */
-var reduce$12 = /*#__PURE__*/ dual(3, (self, zero, f) => {
+var reduce$11 = /*#__PURE__*/ dual(3, (self, zero, f) => {
 	let out = zero;
 	for (const key of keys$10(self)) out = f(out, self[key], key);
 	return out;
@@ -13522,8 +13522,8 @@ var Array_exports = /* @__PURE__ */ __exportAll({
 	match: () => match$11,
 	matchLeft: () => matchLeft,
 	matchRight: () => matchRight,
-	max: () => max$7,
-	min: () => min$7,
+	max: () => max$8,
+	min: () => min$8,
 	modify: () => modify$14,
 	modifyHeadNonEmpty: () => modifyHeadNonEmpty,
 	modifyLastNonEmpty: () => modifyLastNonEmpty,
@@ -13533,7 +13533,7 @@ var Array_exports = /* @__PURE__ */ __exportAll({
 	prepend: () => prepend$4,
 	prependAll: () => prependAll$3,
 	range: () => range$2,
-	reduce: () => reduce$11,
+	reduce: () => reduce$10,
 	reduceRight: () => reduceRight$1,
 	remove: () => remove$14,
 	replace: () => replace$2,
@@ -13556,12 +13556,12 @@ var Array_exports = /* @__PURE__ */ __exportAll({
 	splitWhere: () => splitWhere$1,
 	tail: () => tail$1,
 	tailNonEmpty: () => tailNonEmpty$1,
-	take: () => take$12,
+	take: () => take$11,
 	takeRight: () => takeRight$3,
 	takeWhile: () => takeWhile$3,
 	takeWhileFilter: () => takeWhileFilter$2,
 	unappend: () => unappend,
-	unfold: () => unfold$2,
+	unfold: () => unfold$1,
 	union: () => union$8,
 	unionWith: () => unionWith,
 	unprepend: () => unprepend$1,
@@ -14606,7 +14606,7 @@ var initNonEmpty = (self) => self.slice(0, -1);
 * @category getters
 * @since 2.0.0
 */
-var take$12 = /*#__PURE__*/ dual(2, (self, n) => {
+var take$11 = /*#__PURE__*/ dual(2, (self, n) => {
 	const input = fromIterable$15(self);
 	return input.slice(0, clamp$6(n, input));
 });
@@ -15828,7 +15828,7 @@ var copy$1 = (self) => self.slice();
 * @since 3.8.4
 */
 var pad$1 = /*#__PURE__*/ dual(3, (self, n, fill) => {
-	if (self.length >= n) return take$12(self, n);
+	if (self.length >= n) return take$11(self, n);
 	return appendAll$3(self, makeBy$1(n - self.length, () => fill));
 });
 /**
@@ -16551,7 +16551,7 @@ var separate$1 = /*#__PURE__*/ partition$4(identity$1);
 * @category folding
 * @since 2.0.0
 */
-var reduce$11 = /*#__PURE__*/ dual(3, (self, b, f) => fromIterable$15(self).reduce((b, a, i) => f(b, a, i), b));
+var reduce$10 = /*#__PURE__*/ dual(3, (self, b, f) => fromIterable$15(self).reduce((b, a, i) => f(b, a, i), b));
 /**
 * Folds an iterable from right to left into a single value.
 *
@@ -16825,7 +16825,7 @@ var extend = /*#__PURE__*/ dual(2, (self, f) => self.map((_, i, as) => f(as.slic
 * @category elements
 * @since 2.0.0
 */
-var min$7 = /*#__PURE__*/ dual(2, (self, O) => self.reduce(min$8(O)));
+var min$8 = /*#__PURE__*/ dual(2, (self, O) => self.reduce(min$9(O)));
 /**
 * Returns the maximum element of a non-empty array according to the given
 * `Order`.
@@ -16844,7 +16844,7 @@ var min$7 = /*#__PURE__*/ dual(2, (self, O) => self.reduce(min$8(O)));
 * @category elements
 * @since 2.0.0
 */
-var max$7 = /*#__PURE__*/ dual(2, (self, O) => self.reduce(max$8(O)));
+var max$8 = /*#__PURE__*/ dual(2, (self, O) => self.reduce(max$9(O)));
 /**
 * Builds an array by repeatedly applying a function to a seed value. The
 * function returns `Option.some([element, nextSeed])` to continue, or
@@ -16865,7 +16865,7 @@ var max$7 = /*#__PURE__*/ dual(2, (self, O) => self.reduce(max$8(O)));
 * @category constructors
 * @since 2.0.0
 */
-var unfold$2 = (b, f) => {
+var unfold$1 = (b, f) => {
 	const out = [];
 	let next = b;
 	while (true) {
@@ -17376,8 +17376,8 @@ var BigDecimal_exports = /* @__PURE__ */ __exportAll({
 	isZero: () => isZero$1,
 	make: () => make$70,
 	makeNormalizedUnsafe: () => makeNormalizedUnsafe,
-	max: () => max$6,
-	min: () => min$6,
+	max: () => max$7,
+	min: () => min$7,
 	multiply: () => multiply$2,
 	multiplyAll: () => multiplyAll$2,
 	negate: () => negate$1,
@@ -18121,7 +18121,7 @@ var clamp$5 = /*#__PURE__*/ clamp$7(Order$8);
 * @category math
 * @since 2.0.0
 */
-var min$6 = /*#__PURE__*/ min$8(Order$8);
+var min$7 = /*#__PURE__*/ min$9(Order$8);
 /**
 * Returns the maximum between two `BigDecimal`s.
 *
@@ -18146,7 +18146,7 @@ var min$6 = /*#__PURE__*/ min$8(Order$8);
 * @category math
 * @since 2.0.0
 */
-var max$6 = /*#__PURE__*/ max$8(Order$8);
+var max$7 = /*#__PURE__*/ max$9(Order$8);
 /**
 * Determines the sign of a given `BigDecimal`.
 *
@@ -18962,8 +18962,8 @@ var BigInt_exports = /* @__PURE__ */ __exportAll({
 	isLessThan: () => isLessThan$6,
 	isLessThanOrEqualTo: () => isLessThanOrEqualTo$6,
 	lcm: () => lcm,
-	max: () => max$5,
-	min: () => min$5,
+	max: () => max$6,
+	min: () => min$6,
 	multiply: () => multiply$1,
 	multiplyAll: () => multiplyAll$1,
 	remainder: () => remainder$1,
@@ -19413,7 +19413,7 @@ var clamp$4 = /*#__PURE__*/ clamp$7(Order$7);
 * @category math
 * @since 2.0.0
 */
-var min$5 = /*#__PURE__*/ min$8(Order$7);
+var min$6 = /*#__PURE__*/ min$9(Order$7);
 /**
 * Returns the maximum between two `bigint`s.
 *
@@ -19435,7 +19435,7 @@ var min$5 = /*#__PURE__*/ min$8(Order$7);
 * @category math
 * @since 2.0.0
 */
-var max$5 = /*#__PURE__*/ max$8(Order$7);
+var max$6 = /*#__PURE__*/ max$9(Order$7);
 /**
 * Determines the sign of a given `bigint`.
 *
@@ -19853,7 +19853,7 @@ var ReducerMultiply$1 = /*#__PURE__*/ make$76((a, b) => a * b, bigint1$1, (colle
 * @category math
 * @since 4.0.0
 */
-var CombinerMax$1 = /*#__PURE__*/ max$9(Order$7);
+var CombinerMax$1 = /*#__PURE__*/ max$10(Order$7);
 /**
 * Combiner that returns the minimum `bigint`.
 *
@@ -19867,7 +19867,7 @@ var CombinerMax$1 = /*#__PURE__*/ max$9(Order$7);
 * @category math
 * @since 4.0.0
 */
-var CombinerMin$1 = /*#__PURE__*/ min$9(Order$7);
+var CombinerMin$1 = /*#__PURE__*/ min$10(Order$7);
 //#endregion
 //#region ../../node_modules/effect/dist/Boolean.js
 /**
@@ -21316,10 +21316,10 @@ var Duration_exports = /* @__PURE__ */ __exportAll({
 	isZero: () => isZero,
 	match: () => match$9,
 	matchPair: () => matchPair,
-	max: () => max$4,
+	max: () => max$5,
 	micros: () => micros,
 	millis: () => millis,
-	min: () => min$4,
+	min: () => min$5,
 	minutes: () => minutes,
 	nanos: () => nanos,
 	negate: () => negate,
@@ -22229,7 +22229,7 @@ var Equivalence$6 = (self, that) => matchPair(self, that, {
 * @category ordering
 * @since 2.0.0
 */
-var min$4 = /*#__PURE__*/ min$8(Order$5);
+var min$5 = /*#__PURE__*/ min$9(Order$5);
 /**
 * Returns the larger of two Durations.
 *
@@ -22245,7 +22245,7 @@ var min$4 = /*#__PURE__*/ min$8(Order$5);
 * @category ordering
 * @since 2.0.0
 */
-var max$4 = /*#__PURE__*/ max$8(Order$5);
+var max$5 = /*#__PURE__*/ max$9(Order$5);
 /**
 * Returns a `Duration` constrained between a minimum and maximum value.
 *
@@ -22689,7 +22689,7 @@ var ReducerSum$1 = /*#__PURE__*/ make$76(sum$2, zero);
 * @category math
 * @since 4.0.0
 */
-var CombinerMax = /*#__PURE__*/ max$9(Order$5);
+var CombinerMax = /*#__PURE__*/ max$10(Order$5);
 /**
 * Combiner that returns the minimum `Duration`.
 *
@@ -22703,7 +22703,7 @@ var CombinerMax = /*#__PURE__*/ max$9(Order$5);
 * @category math
 * @since 4.0.0
 */
-var CombinerMin = /*#__PURE__*/ min$9(Order$5);
+var CombinerMin = /*#__PURE__*/ min$10(Order$5);
 //#endregion
 //#region ../../node_modules/effect/dist/Filter.js
 var Filter_exports = /* @__PURE__ */ __exportAll({
@@ -24821,6 +24821,8 @@ var getContext = /*#__PURE__*/ withFiber$1((fiber) => succeed$11(fiber.context))
 /** @internal */
 var contextWith$2 = (f) => withFiber$1((fiber) => f(fiber.context));
 /** @internal */
+var setContext$1 = /*#__PURE__*/ dual(2, (self, context) => updateContext$3(self, constant$2(context)));
+/** @internal */
 var provideContext$4 = /*#__PURE__*/ dual(2, (self, context) => {
 	if (effectIsExit(self)) return self;
 	return updateContext$3(self, merge$5(context));
@@ -30320,8 +30322,8 @@ var Layer_exports = /* @__PURE__ */ __exportAll({
 	parentSpan: () => parentSpan,
 	provide: () => provide$5,
 	provideMerge: () => provideMerge,
-	satisfiesErrorType: () => satisfiesErrorType$2,
-	satisfiesServicesType: () => satisfiesServicesType$2,
+	satisfiesErrorType: () => satisfiesErrorType$1,
+	satisfiesServicesType: () => satisfiesServicesType$1,
 	satisfiesSuccessType: () => satisfiesSuccessType$1,
 	span: () => span$2,
 	succeed: () => succeed$8,
@@ -30606,8 +30608,11 @@ var forkMemoMap = (parent) => sync$6(() => forkMemoMapUnsafe(parent));
 * @category models
 * @since 3.13.0
 */
-var CurrentMemoMap = class extends Service$1()("effect/Layer/CurrentMemoMap") {
-	static getOrCreate = /*#__PURE__*/ getOrElse(this, makeMemoMapUnsafe);
+var CurrentMemoMap = class CurrentMemoMap extends Service$1()("effect/Layer/CurrentMemoMap") {
+	static forkOrCreate(self) {
+		const current = getOrUndefined(self, CurrentMemoMap);
+		return current ? forkMemoMapUnsafe(current) : makeMemoMapUnsafe();
+	}
 };
 /**
 * Builds a layer into an `Effect` value, using the specified `MemoMap` to memoize
@@ -30689,7 +30694,7 @@ var buildWithMemoMap = /*#__PURE__*/ dual(3, (self, memoMap, scope) => provideSe
 * @category destructors
 * @since 2.0.0
 */
-var build = (self) => withFiber$1((fiber) => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.context), getUnsafe$11(fiber.context, Scope)));
+var build = (self) => withFiber$1((fiber) => buildWithMemoMap(self, CurrentMemoMap.forkOrCreate(fiber.context), getUnsafe$11(fiber.context, Scope)));
 /**
 * Builds a layer using an explicit scope.
 *
@@ -30737,7 +30742,7 @@ var build = (self) => withFiber$1((fiber) => buildWithMemoMap(self, CurrentMemoM
 * @category destructors
 * @since 2.0.0
 */
-var buildWithScope = /*#__PURE__*/ dual(2, (self, scope) => withFiber$1((fiber) => buildWithMemoMap(self, CurrentMemoMap.getOrCreate(fiber.context), scope)));
+var buildWithScope = /*#__PURE__*/ dual(2, (self, scope) => withFiber$1((fiber) => buildWithMemoMap(self, CurrentMemoMap.forkOrCreate(fiber.context), scope)));
 /**
 * Constructs a layer that provides a single service from an already available
 * value.
@@ -31936,7 +31941,7 @@ var satisfiesSuccessType$1 = () => (layer) => layer;
 * @category utility types
 * @since 4.0.0
 */
-var satisfiesErrorType$2 = () => (layer) => layer;
+var satisfiesErrorType$1 = () => (layer) => layer;
 /**
 * Ensures that a layer's requirements type extends a given type `R`.
 *
@@ -31968,7 +31973,7 @@ var satisfiesErrorType$2 = () => (layer) => layer;
 * @category utility types
 * @since 4.0.0
 */
-var satisfiesServicesType$2 = () => (layer) => layer;
+var satisfiesServicesType$1 = () => (layer) => layer;
 /**
 * Constructs a new `Layer` which creates a span and registers it as the current
 * parent span.
@@ -33030,9 +33035,9 @@ var setZoneNamedUnsafe$1 = /*#__PURE__*/ dual(isDateTimeArgs, (self, zoneId, opt
 /** @internal */
 var distance$1 = /*#__PURE__*/ dual(2, (self, other) => millis(toEpochMillis$1(other) - toEpochMillis$1(self)));
 /** @internal */
-var min$3 = /*#__PURE__*/ min$8(Order$4);
+var min$4 = /*#__PURE__*/ min$9(Order$4);
 /** @internal */
-var max$3 = /*#__PURE__*/ max$8(Order$4);
+var max$4 = /*#__PURE__*/ max$9(Order$4);
 /** @internal */
 var isGreaterThan$4 = /*#__PURE__*/ isGreaterThan$8(Order$4);
 /** @internal */
@@ -33389,8 +33394,8 @@ var Number_exports = /* @__PURE__ */ __exportAll({
 	isLessThan: () => isLessThan$3,
 	isLessThanOrEqualTo: () => isLessThanOrEqualTo$3,
 	isNumber: () => isNumber$1,
-	max: () => max$2,
-	min: () => min$2,
+	max: () => max$3,
+	min: () => min$3,
 	multiply: () => multiply,
 	multiplyAll: () => multiplyAll,
 	nextPow2: () => nextPow2,
@@ -33820,7 +33825,7 @@ var clamp$1 = /*#__PURE__*/ clamp$7(Order$3);
 * @category math
 * @since 2.0.0
 */
-var min$2 = /*#__PURE__*/ min$8(Order$3);
+var min$3 = /*#__PURE__*/ min$9(Order$3);
 /**
 * Returns the maximum between two `number`s.
 *
@@ -33842,7 +33847,7 @@ var min$2 = /*#__PURE__*/ min$8(Order$3);
 * @category math
 * @since 2.0.0
 */
-var max$2 = /*#__PURE__*/ max$8(Order$3);
+var max$3 = /*#__PURE__*/ max$9(Order$3);
 /**
 * Determines the sign of a given `number`.
 *
@@ -35411,7 +35416,7 @@ var CronProto = {
 		return isCron(that) && equals(this, that);
 	},
 	[symbol$5]() {
-		return pipe(hash$1(this.tz), combine$5(array$2(fromIterable$15(this.seconds))), combine$5(array$2(fromIterable$15(this.minutes))), combine$5(array$2(fromIterable$15(this.hours))), combine$5(array$2(fromIterable$15(this.days))), combine$5(array$2(fromIterable$15(this.months))), combine$5(array$2(fromIterable$15(this.weekdays))));
+		return pipe(hash$1(this.tz), combine$5(hash$1(this.and)), combine$5(array$2(fromIterable$15(this.seconds))), combine$5(array$2(fromIterable$15(this.minutes))), combine$5(array$2(fromIterable$15(this.hours))), combine$5(array$2(fromIterable$15(this.days))), combine$5(array$2(fromIterable$15(this.months))), combine$5(array$2(fromIterable$15(this.weekdays))));
 	},
 	toObject() {
 		return {
@@ -35488,7 +35493,9 @@ var isCron = (u) => hasProperty(u, TypeId$58);
 *
 * Constructs a cron schedule by specifying which seconds, minutes, hours,
 * days, months, and weekdays the schedule should match. Empty arrays mean
-* "match all" for that time unit.
+* "match all" for that time unit. When both days and weekdays are restricted,
+* the default matches either field; set `and: true` to require both fields to
+* match.
 *
 * **Example** (Creating schedules from constraints)
 *
@@ -35591,6 +35598,7 @@ var make$61 = (values) => {
 	o.days = new Set(sort$1(values.days, Order$3));
 	o.months = new Set(sort$1(values.months, Order$3));
 	o.weekdays = new Set(sort$1(values.weekdays, Order$3));
+	o.and = values.and === true;
 	o.tz = fromUndefinedOr(values.tz);
 	const seconds = Array.from(o.seconds);
 	const minutes = Array.from(o.minutes);
@@ -35764,7 +35772,7 @@ var isCronParseError = (u) => hasProperty(u, CronParseErrorTypeId);
 * @since 2.0.0
 */
 var parse$1 = (cron, tz) => {
-	const segments = cron.split(" ").filter(isNonEmpty$5);
+	const segments = cron.trim().split(/\s+/).filter(isNonEmpty$5);
 	if (segments.length !== 5 && segments.length !== 6) return fail$14(new CronParseError({
 		message: `Invalid number of segments in cron expression`,
 		input: cron
@@ -35782,7 +35790,16 @@ var parse$1 = (cron, tz) => {
 		days: parseSegment(days, dayOptions),
 		months: parseSegment(months, monthOptions),
 		weekdays: parseSegment(weekdays, weekdayOptions)
-	}).pipe(map$28(make$61));
+	}).pipe(map$28(({ tz, seconds, minutes, hours, days, months, weekdays }) => make$61({
+		tz,
+		seconds: seconds.values,
+		minutes: minutes.values,
+		hours: hours.values,
+		days: days.values,
+		months: months.values,
+		weekdays: weekdays.values,
+		and: (days.wildcard || weekdays.wildcard) && days.values.size !== 0 && weekdays.values.size !== 0
+	})));
 };
 /**
 * Parses a cron expression into a `Cron` instance, throwing on failure.
@@ -35856,6 +35873,7 @@ var match$4 = (cron, date) => {
 	if (cron.hours.size !== 0 && !cron.hours.has(parts.hour)) return false;
 	if (cron.months.size !== 0 && !cron.months.has(parts.month)) return false;
 	if (cron.days.size === 0 && cron.weekdays.size === 0) return true;
+	if (cron.and) return (cron.days.size === 0 || cron.days.has(parts.day)) && (cron.weekdays.size === 0 || cron.weekdays.has(parts.weekDay));
 	if (cron.weekdays.size === 0) return cron.days.has(parts.day);
 	if (cron.days.size === 0) return cron.weekdays.has(parts.weekDay);
 	return cron.days.has(parts.day) || cron.weekdays.has(parts.weekDay);
@@ -35989,7 +36007,16 @@ var stepCron = (cron, now, direction) => {
 					continue;
 				}
 			}
-			if (cron.weekdays.size !== 0 || cron.days.size !== 0) {
+			if (cron.weekdays.size !== 0 || cron.days.size !== 0) if (cron.and) {
+				const matchesDay = cron.days.size === 0 || cron.days.has(current.getUTCDate());
+				const matchesWeekday = cron.weekdays.size === 0 || cron.weekdays.has(current.getUTCDay());
+				if (!matchesDay || !matchesWeekday) {
+					current.setUTCDate(current.getUTCDate() + tick);
+					current.setUTCHours(boundary.hour, boundary.minute, boundary.second);
+					adjustDst(current);
+					continue;
+				}
+			} else {
 				let a = reverse ? -Infinity : Infinity;
 				let b = reverse ? -Infinity : Infinity;
 				if (cron.weekdays.size !== 0) {
@@ -36018,9 +36045,9 @@ var stepCron = (cron, now, direction) => {
 				const currentMonth = current.getUTCMonth() + 1;
 				const nextMonth = table.month[currentMonth];
 				const clampBoundaryDay = (targetMonthIndex) => {
-					if (cron.days.size !== 0) return boundary.day;
+					if (cron.days.size !== 0 && cron.weekdays.size === 0) return boundary.day;
 					const maxDayInMonth = daysInMonth(new Date(Date.UTC(current.getUTCFullYear(), targetMonthIndex + 1, 0)));
-					return Math.min(boundary.day, maxDayInMonth);
+					return reverse ? maxDayInMonth : 1;
 				};
 				if (nextMonth === void 0) {
 					current.setUTCFullYear(current.getUTCFullYear() + tick);
@@ -36121,7 +36148,7 @@ var sequence = function* (cron, now) {
 * @category instances
 * @since 2.0.0
 */
-var Equivalence$2 = /*#__PURE__*/ make$75((self, that) => restrictionsEquals(self.seconds, that.seconds) && restrictionsEquals(self.minutes, that.minutes) && restrictionsEquals(self.hours, that.hours) && restrictionsEquals(self.days, that.days) && restrictionsEquals(self.months, that.months) && restrictionsEquals(self.weekdays, that.weekdays));
+var Equivalence$2 = /*#__PURE__*/ make$75((self, that) => self.and === that.and && restrictionsEquals(self.seconds, that.seconds) && restrictionsEquals(self.minutes, that.minutes) && restrictionsEquals(self.hours, that.hours) && restrictionsEquals(self.days, that.days) && restrictionsEquals(self.months, that.months) && restrictionsEquals(self.weekdays, that.weekdays));
 var restrictionsArrayEquals = /*#__PURE__*/ Array_$1(/*#__PURE__*/ strictEqual());
 var restrictionsEquals = (self, that) => restrictionsArrayEquals(fromIterable$15(self), fromIterable$15(that));
 /**
@@ -36204,7 +36231,8 @@ var monthOptions = {
 };
 var weekdayOptions = {
 	min: 0,
-	max: 6,
+	max: 7,
+	normalize: (value) => value === 7 ? 0 : value,
 	aliases: {
 		sun: 0,
 		mon: 1,
@@ -36216,12 +36244,17 @@ var weekdayOptions = {
 	}
 };
 var parseSegment = (input, options) => {
-	const capacity = options.max - options.min + 1;
 	const values = /* @__PURE__ */ new Set();
 	const fields = input.split(",");
-	for (const field of fields) {
-		const [raw, step] = splitStep(field);
-		if (raw === "*" && step === void 0) return succeed$12(/* @__PURE__ */ new Set());
+	const first = splitStep(fields[0]);
+	const wildcard = first[0] === "*";
+	const normalize = options.normalize ?? ((value) => value);
+	const add = wildcard && (first[1] === void 0 || first[1] === 1) ? constVoid : (value) => {
+		values.add(normalize(value));
+	};
+	for (let index = 0; index < fields.length; index++) {
+		const field = fields[index];
+		const [raw, step] = index === 0 ? first : splitStep(field);
 		if (step !== void 0) {
 			if (!Number.isInteger(step)) return fail$14(new CronParseError({
 				message: `Expected step value to be a positive integer`,
@@ -36236,8 +36269,10 @@ var parseSegment = (input, options) => {
 				input
 			}));
 		}
-		if (raw === "*") for (let i = options.min; i <= options.max; i += step ?? 1) values.add(i);
-		else {
+		if (raw === "*") {
+			if (index === 0 && (step === void 0 || step === 1)) continue;
+			for (let i = options.min; i <= options.max; i += step ?? 1) add(i);
+		} else {
 			const [left, right] = splitRange(raw, options.aliases);
 			if (!Number.isInteger(left)) return fail$14(new CronParseError({
 				message: `Expected a positive integer`,
@@ -36247,7 +36282,7 @@ var parseSegment = (input, options) => {
 				message: `Expected a value between ${options.min} and ${options.max}`,
 				input
 			}));
-			if (right === void 0) values.add(left);
+			if (right === void 0) for (let i = left; i <= (step === void 0 ? left : options.max); i += step ?? 1) add(i);
 			else {
 				if (!Number.isInteger(right)) return fail$14(new CronParseError({
 					message: `Expected a positive integer`,
@@ -36261,16 +36296,21 @@ var parseSegment = (input, options) => {
 					message: `Invalid value range`,
 					input
 				}));
-				for (let i = left; i <= right; i += step ?? 1) values.add(i);
+				for (let i = left; i <= right; i += step ?? 1) add(i);
 			}
 		}
-		if (values.size >= capacity) return succeed$12(/* @__PURE__ */ new Set());
 	}
-	return succeed$12(values);
+	return succeed$12({
+		values,
+		wildcard
+	});
 };
 var splitStep = (input) => {
 	const separator = input.indexOf("/");
-	if (separator !== -1) return [input.slice(0, separator), Number(input.slice(separator + 1))];
+	if (separator !== -1) {
+		const step = input.slice(separator + 1);
+		return [input.slice(0, separator), decimalRegex.test(step) ? Number(step) : NaN];
+	}
 	return [input, void 0];
 };
 var splitRange = (input, aliases) => {
@@ -36279,8 +36319,9 @@ var splitRange = (input, aliases) => {
 	return [aliasOrValue(input, aliases), void 0];
 };
 function aliasOrValue(field, aliases) {
-	return aliases?.[field.toLocaleLowerCase()] ?? Number(field);
+	return aliases?.[field.toLocaleLowerCase()] ?? (decimalRegex.test(field) ? Number(field) : NaN);
 }
+var decimalRegex = /^\d+$/;
 //#endregion
 //#region ../../node_modules/effect/dist/internal/random.js
 /** @internal */
@@ -36499,37 +36540,14 @@ var matchEffect$1 = /*#__PURE__*/ dual(2, (self, options) => matchCauseEffect$1(
 }));
 //#endregion
 //#region ../../node_modules/effect/dist/Schedule.js
-/**
-* Describes policies for retrying, repeating, and pacing Effect programs.
-*
-* A `Schedule<Output, Input, Error, Env>` is stepped with an input value. Each
-* step either stops or produces an output together with the delay before the
-* next step. Schedules are used by retry, repeat, stream, and channel APIs to
-* decide when work should continue, how long to wait, and when to stop.
-*
-* @since 2.0.0
-*/
 var Schedule_exports = /* @__PURE__ */ __exportAll({
 	CurrentMetadata: () => CurrentMetadata,
 	addDelay: () => addDelay,
 	andThen: () => andThen$1,
 	andThenResult: () => andThenResult,
-	both: () => both,
-	bothLeft: () => bothLeft,
-	bothRight: () => bothRight,
-	bothWith: () => bothWith,
-	collectInputs: () => collectInputs,
-	collectOutputs: () => collectOutputs,
-	collectWhile: () => collectWhile,
 	cron: () => cron,
-	delays: () => delays,
 	duration: () => duration$1,
 	during: () => during,
-	either: () => either,
-	eitherLeft: () => eitherLeft,
-	eitherRight: () => eitherRight,
-	eitherWith: () => eitherWith,
-	elapsed: () => elapsed,
 	exponential: () => exponential,
 	fibonacci: () => fibonacci,
 	fixed: () => fixed,
@@ -36540,24 +36558,18 @@ var Schedule_exports = /* @__PURE__ */ __exportAll({
 	isSchedule: () => isSchedule,
 	jittered: () => jittered,
 	map: () => map$20,
+	max: () => max$2,
+	min: () => min$2,
 	modifyDelay: () => modifyDelay,
 	passthrough: () => passthrough$2,
 	recurs: () => recurs,
-	reduce: () => reduce$10,
-	satisfiesErrorType: () => satisfiesErrorType$1,
-	satisfiesInputType: () => satisfiesInputType,
-	satisfiesOutputType: () => satisfiesOutputType,
-	satisfiesServicesType: () => satisfiesServicesType$1,
 	setInputType: () => setInputType,
 	spaced: () => spaced,
-	take: () => take$11,
 	tap: () => tap$3,
-	tapInput: () => tapInput,
-	tapOutput: () => tapOutput,
 	toStep: () => toStep,
 	toStepWithMetadata: () => toStepWithMetadata,
 	toStepWithSleep: () => toStepWithSleep,
-	unfold: () => unfold$1,
+	upTo: () => upTo,
 	while: () => while_,
 	windowed: () => windowed
 });
@@ -36700,7 +36712,7 @@ var fromStepWithMetadata = (step) => fromStep(map$23(step, (f) => {
 * import { Effect, Schedule } from "effect"
 *
 * // Extract step function from an existing schedule
-* const schedule = Schedule.exponential("100 millis").pipe(Schedule.take(3))
+* const schedule = Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 3 }))
 *
 * const program = Effect.gen(function*() {
 *   const stepFn = yield* Schedule.toStep(schedule)
@@ -36760,7 +36772,7 @@ var toStepWithMetadata = (schedule) => clockWith$2((clock) => map$23(toStep(sche
 * import { Effect, Schedule } from "effect"
 *
 * // Convert schedule to step function with automatic sleeping
-* const schedule = Schedule.spaced("1 second").pipe(Schedule.take(3))
+* const schedule = Schedule.spaced("1 second").pipe(Schedule.upTo({ times: 3 }))
 *
 * const program = Effect.gen(function*() {
 *   const stepWithSleep = yield* Schedule.toStepWithSleep(schedule)
@@ -36793,10 +36805,10 @@ var toStepWithSleep = (schedule) => map$23(toStepWithMetadata(schedule), (step)
 *
 * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
 *
-* // Add a deterministic extra delay based on the schedule output
+* // Add a deterministic extra delay based on the schedule metadata
 * const delayedSchedule = Schedule.addDelay(
-*   Schedule.exponential("100 millis").pipe(Schedule.take(5)),
-*   (output) =>
+*   Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 5 })),
+*   ({ output }) =>
 *     Effect.succeed(Duration.millis(Duration.toMillis(output) * 0.25))
 * )
 *
@@ -36804,7 +36816,7 @@ var toStepWithSleep = (schedule) => map$23(toStepWithMetadata(schedule), (step)
 *   yield* Effect.repeat(
 *     Effect.succeed("delayed task"),
 *     delayedSchedule.pipe(
-*       Schedule.tapOutput((delay) =>
+*       Schedule.tap(({ output: delay }) =>
 *         Console.log(`Base delay: ${delay}`)
 *       )
 *     )
@@ -36814,7 +36826,7 @@ var toStepWithSleep = (schedule) => map$23(toStepWithMetadata(schedule), (step)
 * // Add adaptive delay based on execution count
 * const adaptiveSchedule = Schedule.addDelay(
 *   Schedule.recurs(6),
-*   (executionCount) =>
+*   ({ output: executionCount }) =>
 *     // Increase delay as execution count grows
 *     Effect.succeed(Duration.millis(executionCount * 200))
 * )
@@ -36826,7 +36838,7 @@ var toStepWithSleep = (schedule) => map$23(toStepWithMetadata(schedule), (step)
 *       return "adaptive"
 *     }),
 *     adaptiveSchedule.pipe(
-*       Schedule.tapOutput((count) =>
+*       Schedule.tap(({ output: count }) =>
 *         Console.log(`Execution ${count + 1} with adaptive delay`)
 *       )
 *     )
@@ -36837,8 +36849,8 @@ var toStepWithSleep = (schedule) => map$23(toStepWithMetadata(schedule), (step)
 * const loadByExecution = [1, 3, 2, 4] as const
 *
 * const dynamicSchedule = Schedule.addDelay(
-*   Schedule.spaced("1 second").pipe(Schedule.take(4)),
-*   (executionNumber) => {
+*   Schedule.spaced("1 second").pipe(Schedule.upTo({ times: 4 })),
+*   ({ output: executionNumber }) => {
 *     const load = loadByExecution[executionNumber] ?? 1
 *     return Effect.succeed(Duration.millis(load * 100))
 *   }
@@ -36856,7 +36868,7 @@ var toStepWithSleep = (schedule) => map$23(toStepWithMetadata(schedule), (step)
 *
 * // Combine with retry for progressive backoff
 * const progressiveRetrySchedule = Schedule.addDelay(
-*   Schedule.exponential("50 millis").pipe(Schedule.take(4)),
+*   Schedule.exponential("50 millis").pipe(Schedule.upTo({ times: 4 })),
 *   () => Effect.succeed(Duration.millis(100)) // Fixed additional delay
 * )
 *
@@ -36881,7 +36893,7 @@ var toStepWithSleep = (schedule) => map$23(toStepWithMetadata(schedule), (step)
 * @category delays & timeouts
 * @since 2.0.0
 */
-var addDelay = /*#__PURE__*/ dual(2, (self, f) => modifyDelay(self, (output, delay) => map$23(f(output), (d) => sum$2(fromInputUnsafe(d), fromInputUnsafe(delay)))));
+var addDelay = /*#__PURE__*/ dual(2, (self, f) => modifyDelay(self, (metadata) => map$23(f(metadata), (d) => sum$2(fromInputUnsafe(d), metadata.duration))));
 /**
 * Returns a schedule that runs `self` to completion, then runs `other`, and
 * merges their outputs.
@@ -36895,10 +36907,10 @@ var addDelay = /*#__PURE__*/ dual(2, (self, f) => modifyDelay(self, (output, del
 *
 * // First retry 3 times quickly, then switch to slower retries
 * const quickRetries = Schedule.exponential("100 millis").pipe(
-*   Schedule.take(3)
+*   Schedule.upTo({ times: 3 })
 * )
 * const slowRetries = Schedule.exponential("1 second").pipe(
-*   Schedule.take(2)
+*   Schedule.upTo({ times: 2 })
 * )
 *
 * const combinedRetries = Schedule.andThen(quickRetries, slowRetries)
@@ -36922,7 +36934,7 @@ var addDelay = /*#__PURE__*/ dual(2, (self, f) => modifyDelay(self, (output, del
 * @category sequencing
 * @since 2.0.0
 */
-var andThen$1 = /*#__PURE__*/ dual(2, (self, other) => map$20(andThenResult(self, other), (result) => succeed$11(merge$6(result))));
+var andThen$1 = /*#__PURE__*/ dual(2, (self, other) => map$20(andThenResult(self, other), ({ output }) => succeed$11(merge$6(output))));
 /**
 * Returns a schedule that runs `self` to completion, then runs `other`, and
 * preserves which schedule produced each output.
@@ -36940,8 +36952,8 @@ var andThen$1 = /*#__PURE__*/ dual(2, (self, other) => map$20(andThenResult(self
 *
 * // Track which phase of the schedule we're in
 * const phaseTracker = Schedule.andThenResult(
-*   Schedule.exponential("100 millis").pipe(Schedule.take(2)),
-*   Schedule.spaced("500 millis").pipe(Schedule.take(2))
+*   Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 2 })),
+*   Schedule.spaced("500 millis").pipe(Schedule.upTo({ times: 2 }))
 * )
 *
 * const program = Effect.gen(function*() {
@@ -36951,7 +36963,7 @@ var andThen$1 = /*#__PURE__*/ dual(2, (self, other) => map$20(andThenResult(self
 *       return "task-result"
 *     }),
 *     phaseTracker.pipe(
-*       Schedule.tapOutput((result) =>
+*       Schedule.tap(({ output: result }) =>
 *         Result.match(result, {
 *           onFailure: (phase1Output) => Console.log(`Phase 1: ${phase1Output}`),
 *           onSuccess: (phase2Output) => Console.log(`Phase 2: ${phase2Output}`)
@@ -36968,8 +36980,8 @@ var andThen$1 = /*#__PURE__*/ dual(2, (self, other) => map$20(andThenResult(self
 var andThenResult = /*#__PURE__*/ dual(2, (self, other) => fromStep(sync$6(() => {
 	let currentSide = 0;
 	let currentStep;
-	const left = map$20(self, fail$14);
-	const right = map$20(other, succeed$12);
+	const left = map$20(self, ({ output }) => fail$14(output));
+	const right = map$20(other, ({ output }) => succeed$12(output));
 	return function recur(now, input) {
 		if (currentStep) return currentStep(now, input);
 		return toStep(currentSide === 0 ? left : right).pipe(flatMap$9((step) => {
@@ -36987,366 +36999,68 @@ var andThenResult = /*#__PURE__*/ dual(2, (self, other) => fromStep(sync$6(() =>
 	};
 })));
 /**
-* Combines two `Schedule`s by recurring if both of the two schedules want
-* to recur, using the maximum of the two durations between recurrences and
-* outputting a tuple of the outputs of both schedules.
+* Combines schedules by recurring while all schedules want to recur, using the
+* maximum delay between recurrences and outputting that maximum delay.
 *
 * **When to use**
 *
-* Use when the combined schedule should continue only while both schedules still recur.
+* Use when a combined policy should continue only while every schedule still
+* recurs, and should wait for the slowest schedule between recurrences.
 *
-* **Example** (Combining time and attempt limits)
+* **Example** (Combining retry schedules by their maximum delay)
 *
 * ```ts
 * import { Console, Data, Effect, Schedule } from "effect"
 *
 * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
 *
-* // Both schedules must want to continue for the combined schedule to continue
-* const timeLimit = Schedule.spaced("1 second").pipe(Schedule.take(5)) // max 5 times
-* const attemptLimit = Schedule.recurs(3) // max 3 attempts
-*
-* // Continues only while BOTH schedules want to continue (intersection/AND logic)
-* const bothSchedule = Schedule.both(timeLimit, attemptLimit)
-* // Outputs: [time_result, attempt_count] tuple
+* const retrySchedule = Schedule.max([
+*   Schedule.fixed("5 seconds"),
+*   Schedule.exponential("5 seconds"),
+*   Schedule.spaced("10 seconds")
+* ])
 *
 * const program = Effect.gen(function*() {
-*   const results = yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task completed"
-*     }),
-*     bothSchedule.pipe(
-*       Schedule.tapOutput(([timeResult, attemptResult]) =>
-*         Console.log(`Time: ${timeResult}, Attempts: ${attemptResult}`)
-*       )
-*     )
-*   )
-*
-*   yield* Console.log("Completed all executions")
-* })
-*
-* // Both with different delay strategies - uses maximum delay
-* const fastSchedule = Schedule.fixed("500 millis").pipe(Schedule.take(4))
-* const slowSchedule = Schedule.spaced("2 seconds").pipe(Schedule.take(6))
-*
-* // Will use the slower (maximum) delay and stop when first schedule exhausts
-* const conservativeSchedule = Schedule.both(fastSchedule, slowSchedule)
-*
-* const retryProgram = Effect.gen(function*() {
 *   let attempt = 0
 *
-*   const result = yield* Effect.retry(
+*   yield* Effect.retry(
 *     Effect.gen(function*() {
 *       attempt++
 *       yield* Console.log(`Retry attempt ${attempt}`)
-*
 *       if (attempt < 3) {
 *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
 *       }
-*
-*       return `Success on attempt ${attempt}`
-*     }),
-*     conservativeSchedule
-*   )
-*
-*   yield* Console.log(`Final result: ${result}`)
-* })
-*
-* // Both provides intersection semantics (AND logic)
-* // Compare with either which provides union semantics (OR logic)
-* ```
-*
-* @see {@link either} for continuing while either schedule still recurs
-*
-* @category combining
-* @since 2.0.0
-*/
-var both = /*#__PURE__*/ dual(2, (self, other) => bothWith(self, other, (left, right) => [left, right]));
-/**
-* Combines two `Schedule`s by recurring if both of the two schedules want
-* to recur, using the maximum of the two durations between recurrences and
-* outputting the result of the left schedule (i.e. `self`).
-*
-* **When to use**
-*
-* Use when two schedules must both allow recurrence and only the left schedule's
-* output is needed.
-*
-* **Example** (Combining schedules and keeping the left output)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Combine two schedules, keeping left output
-* const leftSchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.map(() => Effect.succeed("left-result"))
-* )
-* const rightSchedule = Schedule.spaced("50 millis")
-*
-* const combined = Schedule.bothLeft(leftSchedule, rightSchedule)
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task-done"
-*     }),
-*     combined.pipe(Schedule.take(3))
-*   )
-* })
-* ```
-*
-* @category combining
-* @since 2.0.0
-*/
-var bothLeft = /*#__PURE__*/ dual(2, (self, other) => bothWith(self, other, (output) => output));
-/**
-* Combines two `Schedule`s by recurring if both of the two schedules want
-* to recur, using the maximum of the two durations between recurrences and
-* outputting the result of the right schedule (i.e. `other`).
-*
-* **When to use**
-*
-* Use when two schedules must both allow recurrence and only the right
-* schedule's output is needed.
-*
-* **Example** (Combining schedules and keeping the right output)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Combine two schedules, keeping right output
-* const leftSchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.map(() => Effect.succeed("left-result"))
-* )
-* const rightSchedule = Schedule.spaced("50 millis").pipe(
-*   Schedule.map(() => Effect.succeed("right-result"))
-* )
-*
-* const combined = Schedule.bothRight(leftSchedule, rightSchedule)
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task-done"
-*     }),
-*     combined.pipe(Schedule.take(3))
-*   )
-* })
-* ```
-*
-* @category combining
-* @since 2.0.0
-*/
-var bothRight = /*#__PURE__*/ dual(2, (self, other) => bothWith(self, other, (_, output) => output));
-/**
-* Combines two `Schedule`s by recurring if both of the two schedules want
-* to recur, using the maximum of the two durations between recurrences and
-* outputting the result of the combination of both schedule outputs using the
-* specified `combine` function.
-*
-* **When to use**
-*
-* Use when two schedules must both allow recurrence and their outputs should be
-* combined into a custom value.
-*
-* **Example** (Combining schedule outputs)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Combine two schedules with custom output combination
-* const leftSchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.map(() => Effect.succeed("left"))
-* )
-* const rightSchedule = Schedule.spaced("50 millis").pipe(
-*   Schedule.map(() => Effect.succeed("right"))
-* )
-*
-* const combined = Schedule.bothWith(
-*   leftSchedule,
-*   rightSchedule,
-*   (left, right) => `${left}-${right}`
-* )
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task-result"
+*       return "success"
 *     }),
-*     combined.pipe(Schedule.take(3))
+*     retrySchedule.pipe(
+*       Schedule.tap(({ output: duration }) =>
+*         Console.log(`Waiting for the slowest schedule: ${duration}`)
+*       )
+*     )
 *   )
 * })
 * ```
 *
 * @category combining
-* @since 2.0.0
-*/
-var bothWith = /*#__PURE__*/ dual(3, (self, other, combine) => fromStep(map$23(zip$3(toStep(self), toStep(other)), ([stepLeft, stepRight]) => (now, input) => matchEffect$1(stepLeft(now, input), {
-	onSuccess: (leftResult) => stepRight(now, input).pipe(map$23((rightResult) => [combine(leftResult[0], rightResult[0]), max$4(leftResult[1], rightResult[1])]), catchDone((rightDone) => done$2(combine(leftResult[0], rightDone)))),
-	onDone: (leftDone) => stepRight(now, input).pipe(flatMap$9((rightResult) => done$2(combine(leftDone, rightResult[0]))), catchDone((rightDone) => done$2(combine(leftDone, rightDone)))),
-	onFailure: failCause$9
-}))));
-/**
-* Returns a new `Schedule` that follows `self` and outputs the inputs seen so
-* far as an array.
-*
-* **Details**
-*
-* This does not make the schedule run forever. The collected schedule stops
-* when `self` stops and fails when `self` fails.
-*
-* **Example** (Collecting schedule inputs)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Collect all inputs passed to the schedule
-* const inputCollector = Schedule.collectInputs(
-*   Schedule.spaced("100 millis")
-* )
-*
-* const program = Effect.gen(function*() {
-*   let counter = 0
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       counter++
-*       yield* Console.log(`Iteration ${counter}`)
-*       return `result-${counter}`
-*     }),
-*     inputCollector.pipe(Schedule.take(4))
-*   )
-* })
-* ```
-*
-* @category collecting
-* @since 4.0.0
-*/
-var collectInputs = (self) => collectWhile(passthrough$2(self), () => succeed$11(true));
-/**
-* Returns a new `Schedule` that follows `self` and outputs the schedule outputs
-* seen so far as an array.
-*
-* **Details**
-*
-* This does not make the schedule run forever. The collected schedule stops
-* when `self` stops and fails when `self` fails.
-*
-* **Example** (Collecting schedule outputs)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Collect all outputs from the schedule
-* const outputCollector = Schedule.collectOutputs(
-*   Schedule.recurs(4)
-* )
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task-result"
-*     }),
-*     outputCollector.pipe(Schedule.take(4))
-*   )
-* })
-* ```
-*
-* @category collecting
 * @since 4.0.0
 */
-var collectOutputs = (self) => collectWhile(self, () => succeed$11(true));
-/**
-* Returns a new `Schedule` that recurs as long as the specified `predicate`
-* returns `true`, collecting all outputs of the schedule into an array.
-*
-* **Example** (Collecting outputs while a condition holds)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Collect outputs while condition is met
-* const collectWhileSmall = Schedule.collectWhile(
-*   Schedule.exponential("100 millis"),
-*   (metadata) =>
-*     Effect.succeed(metadata.attempt <= 5 && metadata.elapsed < 2000)
-* )
-*
-* const conditionalProgram = Effect.gen(function*() {
-*   let attempt = 0
-*
-*   const attempts = yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       attempt++
-*       yield* Console.log(`Retry attempt ${attempt}`)
-*       return `attempt-${attempt}`
-*     }),
-*     collectWhileSmall
-*   )
-*
-*   yield* Console.log(`Collected attempts: [${attempts.join(", ")}]`)
-* })
-*
-* // Collect with effectful predicate
-* const collectWithCheck = Schedule.collectWhile(
-*   Schedule.fixed("1 second"),
-*   (metadata) =>
-*     Effect.gen(function*() {
-*       const shouldContinue = metadata.attempt < 5
-*       yield* Console.log(
-*         `Check ${metadata.attempt}: continue = ${shouldContinue}`
-*       )
-*       return shouldContinue
-*     })
-* )
-*
-* const effectfulProgram = Effect.gen(function*() {
-*   const results = yield* Effect.repeat(
-*     Effect.succeed("checked"),
-*     collectWithCheck
-*   )
-*
-*   yield* Console.log(`Final collection: ${results.length} items`)
-* })
-*
-* // Collect samples with condition
-* const samples = [12, 18, 24, 30, 36]
-*
-* const collectSamples = Schedule.collectWhile(
-*   Schedule.spaced("200 millis"),
-*   (metadata) =>
-*     Effect.succeed(metadata.attempt <= 5 && metadata.elapsed < 2000)
-* )
-*
-* const samplingProgram = Effect.gen(function*() {
-*   let index = 0
-*   const collected = yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       const sample = samples[index++]
-*       yield* Console.log(`Sample: ${sample}`)
-*       return sample
-*     }),
-*     collectSamples
-*   )
-*
-*   const average = collected.reduce((sum, s) => sum + s, 0) / collected.length
-*   yield* Console.log(
-*     `Collected ${collected.length} samples, average: ${average.toFixed(1)}`
-*   )
-* })
-* ```
-*
-* @category collecting
-* @since 2.0.0
-*/
-var collectWhile = /*#__PURE__*/ dual(2, (self, predicate) => reduce$10(while_(self, predicate), () => [], (outputs, output) => {
-	outputs.push(output);
-	return outputs;
-}));
+var max$2 = (schedules) => fromStep(map$23(all$3(schedules.map(toStep)), (steps) => (now, input) => flatMap$9(forEach$9(steps, (step) => matchEffect$1(step(now, input), {
+	onSuccess: (result) => succeed$11(result[1]),
+	onDone: () => undefined_$2,
+	onFailure: failCause$9
+})), (results) => {
+	const duration = maxDuration(results);
+	if (duration === void 0) return done$2(zero);
+	return succeed$11([duration, duration]);
+})));
+var maxDuration = (results) => {
+	let max = results[0];
+	for (let i = 1; i < results.length; i++) {
+		max = results[i] && max && max$5(max, results[i]);
+		if (max === void 0) break;
+	}
+	return max;
+};
 /**
 * Returns a new `Schedule` that recurs on the specified `Cron` schedule and
 * outputs the duration between recurrences.
@@ -37368,8 +37082,8 @@ var collectWhile = /*#__PURE__*/ dual(2, (self, predicate) => reduce$10(while_(s
 *       return "minute"
 *     }),
 *     everyMinute.pipe(
-*       Schedule.take(3), // Run only 3 times for demo
-*       Schedule.tapOutput((duration) =>
+*       Schedule.upTo({ times: 3 }), // Run only 3 times for demo
+*       Schedule.tap(({ output: duration }) =>
 *         Console.log(`Next execution in: ${duration}`)
 *       )
 *     )
@@ -37389,7 +37103,7 @@ var collectWhile = /*#__PURE__*/ dual(2, (self, predicate) => reduce$10(while_(s
 *       return "backup-done"
 *     }),
 *     dailyBackup.pipe(
-*       Schedule.take(2) // Run 2 times for demo
+*       Schedule.upTo({ times: 2 }) // Run 2 times for demo
 *     )
 *   )
 * })
@@ -37408,7 +37122,7 @@ var collectWhile = /*#__PURE__*/ dual(2, (self, predicate) => reduce$10(while_(s
 *       yield* Console.log(`Report generated: ${JSON.stringify(report)}`)
 *       return report
 *     }),
-*     weeklyReport.pipe(Schedule.take(1))
+*     weeklyReport.pipe(Schedule.upTo({ times: 1 }))
 *   )
 * })
 *
@@ -37427,7 +37141,7 @@ var collectWhile = /*#__PURE__*/ dual(2, (self, predicate) => reduce$10(while_(s
 *       return status
 *     }),
 *     businessHoursCheck.pipe(
-*       Schedule.take(4) // Demo with 4 checks
+*       Schedule.upTo({ times: 4 }) // Demo with 4 checks
 *     )
 *   )
 * })
@@ -37443,13 +37157,13 @@ var collectWhile = /*#__PURE__*/ dual(2, (self, predicate) => reduce$10(while_(s
 *       yield* Console.log(`Processed ${invoiceCount} invoices`)
 *       return { count: invoiceCount, batch: "2024-01-a" }
 *     }),
-*     monthlyInvoice.pipe(Schedule.take(1))
+*     monthlyInvoice.pipe(Schedule.upTo({ times: 1 }))
 *   )
 * })
 *
 * // Complex cron with error handling
 * const complexCron = Schedule.cron("0 2,4,6 * * *").pipe(
-*   Schedule.tapOutput((duration) =>
+*   Schedule.tap(({ output: duration }) =>
 *     Console.log(`Scheduled to run again in ${duration}`)
 *   )
 * )
@@ -37466,7 +37180,7 @@ var collectWhile = /*#__PURE__*/ dual(2, (self, predicate) => reduce$10(while_(s
 *       }
 *       return "success"
 *     }),
-*     complexCron.pipe(Schedule.take(3))
+*     complexCron.pipe(Schedule.upTo({ times: 3 }))
 *   ).pipe(
 *     Effect.catch((error: unknown) =>
 *       Console.log(`Cron task error: ${String(error)}`)
@@ -37479,97 +37193,15 @@ var collectWhile = /*#__PURE__*/ dual(2, (self, predicate) => reduce$10(while_(s
 * @since 2.0.0
 */
 var cron = (expression, tz) => {
-	return fromStep(map$23(fromResult$1(isCron(expression) ? succeed$12(expression) : parse$1(expression, tz)), (cron) => (now, _) => sync$6(() => {
-		const duration = millis(next$1(cron, now).getTime() - now);
-		return [duration, duration];
-	})));
+	return fromStep(map$23(fromResult$1(isCron(expression) ? succeed$12(expression) : parse$1(expression, tz)), (cron) => (now, _) => {
+		if (now === Number.POSITIVE_INFINITY) return done$2(zero);
+		return sync$6(() => {
+			const duration = millis(next$1(cron, now).getTime() - now);
+			return [duration, duration];
+		});
+	}));
 };
 /**
-* Returns a new schedule that outputs the delay between each occurrence.
-*
-* **Example** (Extracting schedule delays)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Extract delays from an exponential backoff schedule
-* const exponentialDelays = Schedule.delays(
-*   Schedule.exponential("100 millis").pipe(Schedule.take(5))
-* )
-*
-* const delayProgram = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task result"
-*     }),
-*     exponentialDelays.pipe(
-*       Schedule.tapOutput((delay) =>
-*         Console.log(`Waiting ${delay} before next execution`)
-*       )
-*     )
-*   )
-* })
-*
-* // Monitor delays from a Fibonacci schedule
-* const fibonacciDelays = Schedule.delays(
-*   Schedule.fibonacci("200 millis").pipe(Schedule.take(8))
-* )
-*
-* const fibDelayProgram = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Console.log("Fibonacci task"),
-*     fibonacciDelays.pipe(
-*       Schedule.tapOutput((delay) => Console.log(`Fibonacci delay: ${delay}`))
-*     )
-*   )
-* })
-*
-* // Extract delays for analysis or logging
-* const analyzeDelays = Schedule.delays(
-*   Schedule.spaced("1 second").pipe(Schedule.take(3))
-* ).pipe(
-*   Schedule.tapOutput((delay) =>
-*     Effect.gen(function*() {
-*       yield* Console.log(`Recorded delay: ${delay}`)
-*       // In real applications, might send to metrics system
-*     })
-*   )
-* )
-*
-* // Combine delays with other schedules for complex timing
-* const adaptiveSchedule = Schedule.unfold(100, (delay) => Effect.succeed(delay * 1.5)).pipe(
-*   Schedule.take(6)
-* )
-*
-* const adaptiveDelays = Schedule.delays(adaptiveSchedule)
-*
-* const adaptiveProgram = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Adaptive task execution")
-*       return "completed"
-*     }),
-*     adaptiveDelays.pipe(
-*       Schedule.tapOutput((delay) => Console.log(`Adaptive delay: ${delay}`))
-*     )
-*   )
-* })
-*
-* // Use delays to implement custom timing logic
-* const customTimingSchedule = Schedule.delays(
-*   Schedule.exponential("50 millis").pipe(Schedule.take(4))
-* ).pipe(
-*   Schedule.map((delay) => Effect.succeed(`Next execution in ${delay}`)),
-*   Schedule.tapOutput((message) => Console.log(message))
-* )
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-var delays = (self) => fromStep(map$23(toStep(self), (step) => (now, input) => catchDone(map$23(step(now, input), ([_, duration]) => [duration, duration]), (_) => done$2(zero))));
-/**
 * Returns a schedule that recurs once after the specified duration.
 *
 * **When to use**
@@ -37627,7 +37259,7 @@ var duration$1 = (durationInput) => {
 *       return "task done"
 *     }),
 *     fiveSecondSchedule.pipe(
-*       Schedule.tapOutput((elapsedDuration) =>
+*       Schedule.tap(({ output: elapsedDuration }) =>
 *         Console.log(`Total elapsed: ${elapsedDuration}`)
 *       )
 *     )
@@ -37637,10 +37269,11 @@ var duration$1 = (durationInput) => {
 * })
 *
 * // Combine with other schedules for time-bounded execution
-* const timeAndCountLimited = Schedule.spaced("1 second").pipe(
-*   Schedule.both(Schedule.during("10 seconds")), // Stop after 10 seconds OR
-*   Schedule.both(Schedule.recurs(15)) // 15 attempts, whichever comes first
-* )
+* const timeAndCountLimited = Schedule.max([
+*   Schedule.spaced("1 second"),
+*   Schedule.during("10 seconds"), // Stop after 10 seconds OR
+*   Schedule.recurs(15) // 15 attempts, whichever comes first
+* ])
 *
 * // Burst execution within time window
 * const burstWindow = Schedule.during("3 seconds")
@@ -37660,9 +37293,10 @@ var duration$1 = (durationInput) => {
 * })
 *
 * // Timed retry window - retry for up to 30 seconds
-* const timedRetry = Schedule.exponential("200 millis").pipe(
-*   Schedule.both(Schedule.during("30 seconds"))
-* )
+* const timedRetry = Schedule.max([
+*   Schedule.exponential("200 millis"),
+*   Schedule.during("30 seconds")
+* ])
 *
 * const retryProgram = Effect.gen(function*() {
 *   let attempt = 0
@@ -37692,160 +37326,52 @@ var duration$1 = (durationInput) => {
 * @category constructors
 * @since 4.0.0
 */
-var during = (duration) => while_(elapsed, ({ output }) => succeed$11(isLessThanOrEqualTo$5(output, fromInputUnsafe(duration))));
+var during = (duration) => {
+	const durationMillis = toMillis(duration);
+	return fromStepWithMetadata(succeed$11((meta) => {
+		const elapsed = millis(meta.elapsed);
+		return meta.elapsed > durationMillis ? succeed$11([elapsed, zero]) : done$2(elapsed);
+	}));
+};
 /**
-* Combines two `Schedule`s by recurring if either of the two schedules wants
-* to recur, using the minimum of the two durations between recurrences and
-* outputting a tuple of the outputs of both schedules.
+* Combines schedules by recurring while at least one schedule wants to recur,
+* using the minimum delay between recurrences and outputting that minimum delay.
 *
 * **When to use**
 *
-* Use when the combined schedule should continue while at least one schedule still recurs.
+* Use when a combined policy should continue while any schedule still recurs,
+* and should wait for the fastest schedule between recurrences.
 *
-* **Example** (Combining schedules with either semantics)
+* **Example** (Combining retry schedules by their minimum delay)
 *
 * ```ts
 * import { Console, Data, Effect, Schedule } from "effect"
 *
 * class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
 *
-* // Either continues as long as at least one schedule wants to continue
-* const timeBasedSchedule = Schedule.spaced("2 seconds").pipe(Schedule.take(3))
-* const countBasedSchedule = Schedule.recurs(5)
-*
-* // Continues until both schedules are exhausted (either still wants to recur)
-* const eitherSchedule = Schedule.either(timeBasedSchedule, countBasedSchedule)
-* // Outputs: [time_result, count_result] tuple
+* const retrySchedule = Schedule.min([
+*   Schedule.fixed("5 seconds"),
+*   Schedule.exponential("5 seconds"),
+*   Schedule.spaced("10 seconds")
+* ])
 *
 * const program = Effect.gen(function*() {
-*   const results = yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task completed"
-*     }),
-*     eitherSchedule.pipe(
-*       Schedule.tapOutput(([timeResult, countResult]) =>
-*         Console.log(`Time: ${timeResult}, Count: ${countResult}`)
-*       )
-*     )
-*   )
-*
-*   yield* Console.log(`Total executions: ${results.length}`)
-* })
-*
-* // Either with different delay strategies
-* const aggressiveRetry = Schedule.exponential("100 millis").pipe(
-*   Schedule.take(3)
-* )
-* const fallbackRetry = Schedule.fixed("5 seconds").pipe(Schedule.take(2))
-*
-* // Will use the more aggressive retry until it's exhausted, then fallback
-* const combinedRetry = Schedule.either(aggressiveRetry, fallbackRetry)
-*
-* const retryProgram = Effect.gen(function*() {
 *   let attempt = 0
 *
-*   const result = yield* Effect.retry(
+*   yield* Effect.retry(
 *     Effect.gen(function*() {
 *       attempt++
 *       yield* Console.log(`Retry attempt ${attempt}`)
-*
-*       if (attempt < 6) {
+*       if (attempt < 3) {
 *         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
 *       }
-*
-*       return `Success on attempt ${attempt}`
-*     }),
-*     combinedRetry
-*   )
-*
-*   yield* Console.log(`Final result: ${result}`)
-* })
-*
-* // Either provides union semantics (OR logic)
-* // Compare with both, which provides intersection semantics (AND logic)
-* ```
-*
-* @see {@link both} for continuing only while both schedules still recur
-*
-* @category combining
-* @since 2.0.0
-*/
-var either = /*#__PURE__*/ dual(2, (self, other) => eitherWith(self, other, (left, right) => [left, right]));
-/**
-* Combines two `Schedule`s by recurring if either of the two schedules wants
-* to recur, using the minimum of the two durations between recurrences and
-* outputting the result of the left schedule (i.e. `self`).
-*
-* **When to use**
-*
-* Use when either schedule may keep recurrence going and only the left
-* schedule's output is needed.
-*
-* **Example** (Combining either schedules and keeping the left output)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Combine two schedules with either semantics, keeping left output
-* const primarySchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.map(() => Effect.succeed("primary-result")),
-*   Schedule.take(2)
-* )
-* const backupSchedule = Schedule.spaced("500 millis").pipe(
-*   Schedule.map(() => Effect.succeed("backup-result"))
-* )
-*
-* const combined = Schedule.eitherLeft(primarySchedule, backupSchedule)
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task-done"
-*     }),
-*     combined.pipe(Schedule.take(5))
-*   )
-* })
-* ```
-*
-* @category combining
-* @since 4.0.0
-*/
-var eitherLeft = /*#__PURE__*/ dual(2, (self, other) => eitherWith(self, other, (output) => output));
-/**
-* Combines two `Schedule`s by recurring if either of the two schedules wants
-* to recur, using the minimum of the two durations between recurrences and
-* outputting the result of the right schedule (i.e. `other`).
-*
-* **When to use**
-*
-* Use when either schedule may keep recurrence going and only the right
-* schedule's output is needed.
-*
-* **Example** (Combining either schedules and keeping the right output)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Combine two schedules with either semantics, keeping right output
-* const primarySchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.map(() => Effect.succeed("primary-result")),
-*   Schedule.take(2)
-* )
-* const backupSchedule = Schedule.spaced("500 millis").pipe(
-*   Schedule.map(() => Effect.succeed("backup-result"))
-* )
-*
-* const combined = Schedule.eitherRight(primarySchedule, backupSchedule)
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task-done"
+*       return "success"
 *     }),
-*     combined.pipe(Schedule.take(5))
+*     retrySchedule.pipe(
+*       Schedule.tap(({ output: duration }) =>
+*         Console.log(`Waiting for the fastest schedule: ${duration}`)
+*       )
+*     )
 *   )
 * })
 * ```
@@ -37853,89 +37379,23 @@ var eitherLeft = /*#__PURE__*/ dual(2, (self, other) => eitherWith(self, other,
 * @category combining
 * @since 4.0.0
 */
-var eitherRight = /*#__PURE__*/ dual(2, (self, other) => eitherWith(self, other, (_, output) => output));
-/**
-* Combines two `Schedule`s by recurring if either of the two schedules wants
-* to recur, using the minimum of the two durations between recurrences and
-* outputting the result of the combination of both schedule outputs using the
-* specified `combine` function.
-*
-* **When to use**
-*
-* Use when either schedule may keep recurrence going and their outputs should be
-* combined into a custom value.
-*
-* **Example** (Combining either schedule outputs)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Combine schedules with either semantics and custom combination
-* const primarySchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.map(() => Effect.succeed("primary")),
-*   Schedule.take(2)
-* )
-* const fallbackSchedule = Schedule.spaced("500 millis").pipe(
-*   Schedule.map(() => Effect.succeed("fallback"))
-* )
-*
-* const combined = Schedule.eitherWith(
-*   primarySchedule,
-*   fallbackSchedule,
-*   (primary, fallback) => `${primary}+${fallback}`
-* )
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task-result"
-*     }),
-*     combined.pipe(Schedule.take(5))
-*   )
-* })
-* ```
-*
-* @category combining
-* @since 2.0.0
-*/
-var eitherWith = /*#__PURE__*/ dual(3, (self, other, combine) => fromStep(map$23(zip$3(toStep(self), toStep(other)), ([stepLeft, stepRight]) => (now, input) => matchEffect$1(stepLeft(now, input), {
-	onSuccess: (leftResult) => stepRight(now, input).pipe(map$23((rightResult) => [combine(leftResult[0], rightResult[0]), min$4(leftResult[1], rightResult[1])]), catchDone((rightDone) => succeed$11([combine(leftResult[0], rightDone), leftResult[1]]))),
-	onFailure: failCause$9,
-	onDone: (leftDone) => stepRight(now, input).pipe(map$23((rightResult) => [combine(leftDone, rightResult[0]), rightResult[1]]), catchDone((rightDone) => done$2(combine(leftDone, rightDone))))
-}))));
-/**
-* Schedule that always recurs and returns the total elapsed duration since the
-* first recurrence.
-*
-* **Details**
-*
-* This schedule never stops and outputs the cumulative time that has passed since the schedule
-* started executing. Useful for tracking execution time or implementing time-based logic.
-*
-* **Example** (Measuring elapsed schedule time)
-*
-* ```ts
-* import { Console, Duration, Effect, Schedule } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Console.log("Running task..."),
-*     Schedule.spaced("1 second").pipe(
-*       Schedule.both(Schedule.elapsed),
-*       Schedule.tapOutput(([count, duration]) =>
-*         Console.log(`Run ${count}, elapsed: ${Duration.toMillis(duration)}ms`)
-*       ),
-*       Schedule.take(5)
-*     )
-*   )
-* })
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-var elapsed = /*#__PURE__*/ fromStepWithMetadata(/*#__PURE__*/ succeed$11((meta) => succeed$11([millis(meta.elapsed), zero])));
+var min$2 = (schedules) => fromStep(map$23(all$3(schedules.map(toStep)), (steps) => (now, input) => flatMap$9(forEach$9(steps, (step) => matchEffect$1(step(now, input), {
+	onSuccess: (result) => succeed$11(result[1]),
+	onDone: () => undefined_$2,
+	onFailure: failCause$9
+})), (results) => {
+	const duration = minDuration(results);
+	if (duration === void 0) return done$2(zero);
+	return succeed$11([duration, duration]);
+})));
+var minDuration = (results) => {
+	let min = void 0;
+	for (let i = 0; i < results.length; i++) {
+		const duration = results[i];
+		if (duration !== void 0) min = min === void 0 ? duration : min$5(min, duration);
+	}
+	return min;
+};
 /**
 * Schedule that always recurs, but will wait a certain amount between
 * repetitions, given by `base * factor.pow(n)`, where `n` is the number of
@@ -37957,9 +37417,10 @@ var elapsed = /*#__PURE__*/ fromStepWithMetadata(/*#__PURE__*/ succeed$11((meta)
 * // Delays: 200ms, 300ms, 450ms, 675ms, 1012ms, ...
 *
 * // Retry with exponential backoff (limited to 5 attempts)
-* const retryPolicy = Schedule.exponential("50 millis").pipe(
-*   Schedule.both(Schedule.recurs(5))
-* )
+* const retryPolicy = Schedule.max([
+*   Schedule.exponential("50 millis"),
+*   Schedule.recurs(5)
+* ])
 *
 * const program = Effect.gen(function*() {
 *   let attempt = 0
@@ -38023,9 +37484,11 @@ var exponential = (base, factor = 2) => {
 *
 *       return `Success on attempt ${attempt}`
 *     }),
-*     Schedule.fibonacci("50 millis").pipe(
-*       Schedule.both(Schedule.recurs(6)), // Maximum 6 retries
-*       Schedule.tapOutput((delay) => Console.log(`Next retry in ${delay}`))
+*     Schedule.max([
+*       Schedule.fibonacci("50 millis"),
+*       Schedule.recurs(6) // Maximum 6 retries
+*     ]).pipe(
+*       Schedule.tap(({ output: delay }) => Console.log(`Next retry in ${delay}`))
 *     )
 *   )
 *
@@ -38039,7 +37502,7 @@ var exponential = (base, factor = 2) => {
 * }).pipe(
 *   Effect.repeat(
 *     Schedule.fibonacci("200 millis").pipe(
-*       Schedule.take(8) // First 8 heartbeats
+*       Schedule.upTo({ times: 8 }) // First 8 heartbeats
 *     )
 *   )
 * )
@@ -38105,7 +37568,7 @@ var fibonacci = (one) => {
 *   yield* Effect.sleep("200 millis") // simulate health check work
 *   return "healthy"
 * }).pipe(
-*   Effect.repeat(Schedule.fixed("2 seconds").pipe(Schedule.take(5)))
+*   Effect.repeat(Schedule.fixed("2 seconds").pipe(Schedule.upTo({ times: 5 })))
 * )
 *
 * // Difference between fixed and spaced:
@@ -38122,12 +37585,12 @@ var fibonacci = (one) => {
 * // Fixed schedule: if task takes 1.5s but interval is 1s,
 * // next execution happens immediately (no pile-up)
 * const fixedSchedule = longRunningTask.pipe(
-*   Effect.repeat(Schedule.fixed("1 second").pipe(Schedule.take(3)))
+*   Effect.repeat(Schedule.fixed("1 second").pipe(Schedule.upTo({ times: 3 })))
 * )
 *
 * // Comparing with spaced (waits 1s AFTER each task)
 * const spacedSchedule = longRunningTask.pipe(
-*   Effect.repeat(Schedule.spaced("1 second").pipe(Schedule.take(3)))
+*   Effect.repeat(Schedule.spaced("1 second").pipe(Schedule.upTo({ times: 3 })))
 * )
 *
 * const program = Effect.gen(function*() {
@@ -38165,8 +37628,14 @@ var fixed = (interval) => {
 	}));
 };
 /**
-* Returns a new `Schedule` that maps the output of this schedule using the
-* specified function.
+* Returns a new `Schedule` that maps each schedule decision to a new output
+* using the full schedule metadata.
+*
+* **Details**
+*
+* The callback receives the schedule input, output, selected delay duration,
+* current attempt, and elapsed timing information. Return either a plain value
+* or an `Effect` that produces the new output.
 *
 * **Example** (Mapping schedule outputs)
 *
@@ -38175,17 +37644,17 @@ var fixed = (interval) => {
 *
 * // Transform schedule output from number to string
 * const countSchedule = Schedule.recurs(5).pipe(
-*   Schedule.map((count) => Effect.succeed(`Execution #${count + 1}`))
+*   Schedule.map(({ output: count }) => Effect.succeed(`Execution #${count + 1}`))
 * )
 *
 * // Map schedule delays to human-readable format
 * const readableDelays = Schedule.exponential("100 millis").pipe(
-*   Schedule.map((duration) => Effect.succeed(`Next retry in ${duration}`))
+*   Schedule.map(({ output: delay }) => Effect.succeed(`Next retry in ${delay}`))
 * )
 *
 * // Transform numeric output to structured data
 * const structuredSchedule = Schedule.spaced("1 second").pipe(
-*   Schedule.map((recurrence) => Effect.succeed({
+*   Schedule.map(({ output: recurrence }) => Effect.succeed({
 *     iteration: recurrence + 1,
 *     phase: recurrence < 5 ? "warmup" as const : "steady" as const
 *   }))
@@ -38195,8 +37664,8 @@ var fixed = (interval) => {
 *   const results = yield* Effect.repeat(
 *     Effect.succeed("task completed"),
 *     structuredSchedule.pipe(
-*       Schedule.take(8),
-*       Schedule.tapOutput((info) =>
+*       Schedule.upTo({ times: 8 }),
+*       Schedule.tap(({ output: info }) =>
 *         Console.log(
 *           `${info.phase} phase - iteration ${info.iteration}`
 *         )
@@ -38209,7 +37678,7 @@ var fixed = (interval) => {
 *
 * // Map with effectful transformation
 * const effectfulMap = Schedule.fixed("2 seconds").pipe(
-*   Schedule.map((count) =>
+*   Schedule.map(({ output: count }) =>
 *     Effect.gen(function*() {
 *       yield* Console.log(`Processing count: ${count}`)
 *       return count * 10
@@ -38217,45 +37686,55 @@ var fixed = (interval) => {
 *   )
 * )
 *
-* // Combine mapping with other schedule operations
+* // Use timing metadata in the mapped output
 * const complexSchedule = Schedule.fibonacci("100 millis").pipe(
-*   Schedule.map((delay) => Effect.succeed(`Delay: ${delay}`))
+*   Schedule.map(({ output: delay, attempt }) =>
+*     Effect.succeed(`Attempt ${attempt} delay: ${delay}`)
+*   )
 * )
 * ```
 *
 * @category mapping
 * @since 2.0.0
 */
-var map$20 = /*#__PURE__*/ dual(2, (self, f) => {
-	const handle = matchEffect$1({
+var map$20 = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self), (step) => {
+	const meta = metadataFn();
+	return (now, input) => matchEffect$1(step(now, input), {
 		onSuccess: ([output, duration]) => {
-			const result = f(output);
+			const result = f({
+				...meta(now, input),
+				output,
+				duration
+			});
 			if (!isEffect$1(result)) return succeed$11([result, duration]);
 			return map$23(result, (output) => [output, duration]);
 		},
 		onFailure: failCause$9,
 		onDone: (output) => {
-			const result = f(output);
+			const result = f({
+				...meta(now, input),
+				output,
+				duration: zero
+			});
 			if (!isEffect$1(result)) return done$2(result);
 			return flatMap$9(result, done$2);
 		}
 	});
-	return fromStep(map$23(toStep(self), (step) => (now, input) => handle(step(now, input))));
-});
+})));
 /**
 * Returns a new `Schedule` that modifies the delay of the next recurrence
 * of the schedule using the specified effectful function.
 *
-* **Example** (Modifying delays from schedule output)
+* **Example** (Modifying delays from schedule metadata)
 *
 * ```ts
 * import { Console, Duration, Effect, Schedule } from "effect"
 *
 * // Modify delays based on output - increase delay on high iteration counts
 * const adaptiveDelay = Schedule.recurs(10).pipe(
-*   Schedule.modifyDelay((output, delay) => {
+*   Schedule.modifyDelay(({ output, duration }) => {
 *     // Double the delay if we're seeing high iteration counts
-*     return Effect.succeed(output > 5 ? Duration.times(delay, 2) : delay)
+*     return Effect.succeed(output > 5 ? Duration.times(duration, 2) : duration)
 *   })
 * )
 *
@@ -38267,7 +37746,7 @@ var map$20 = /*#__PURE__*/ dual(2, (self, f) => {
 *       yield* Console.log(`Attempt ${counter}`)
 *       return counter
 *     }),
-*     adaptiveDelay.pipe(Schedule.take(8))
+*     adaptiveDelay.pipe(Schedule.upTo({ times: 8 }))
 *   )
 * })
 * ```
@@ -38275,7 +37754,14 @@ var map$20 = /*#__PURE__*/ dual(2, (self, f) => {
 * @category delays & timeouts
 * @since 2.0.0
 */
-var modifyDelay = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self), (step) => (now, input) => flatMap$9(step(now, input), ([output, delay]) => map$23(f(output, delay), (delay) => [output, fromInputUnsafe(delay)])))));
+var modifyDelay = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self), (step) => {
+	const meta = metadataFn();
+	return (now, input) => flatMap$9(step(now, input), ([output, duration]) => map$23(f({
+		...meta(now, input),
+		output,
+		duration
+	}), (replacement) => [output, fromInputUnsafe(replacement)]));
+})));
 /**
 * Returns a new `Schedule` that randomly adjusts each recurrence delay.
 *
@@ -38293,8 +37779,8 @@ var modifyDelay = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self
 * @category delays & timeouts
 * @since 2.0.0
 */
-var jittered = (self) => modifyDelay(self, (_, delay) => map$23(randomNext, (random) => {
-	const millis$1 = toMillis(fromInputUnsafe(delay));
+var jittered = (self) => modifyDelay(self, ({ duration }) => map$23(randomNext, (random) => {
+	const millis$1 = toMillis(duration);
 	return millis(millis$1 * .8 * (1 - random) + millis$1 * 1.2 * random);
 }));
 /**
@@ -38307,7 +37793,7 @@ var jittered = (self) => modifyDelay(self, (_, delay) => map$23(randomNext, (ran
 *
 * // Create a schedule that outputs the inputs instead of original outputs
 * const inputSchedule = Schedule.passthrough(
-*   Schedule.exponential("100 millis").pipe(Schedule.take(3))
+*   Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 3 }))
 * )
 *
 * const program = Effect.gen(function*() {
@@ -38377,9 +37863,10 @@ var passthrough$2 = (self) => fromStep(map$23(toStep(self), (step) => (now, inpu
 * })
 *
 * // Combining recurs with other schedules for sophisticated retry logic
-* const complexRetry = Schedule.exponential("100 millis").pipe(
-*   Schedule.both(Schedule.recurs(3)) // At most 3 retries
-* )
+* const complexRetry = Schedule.max([
+*   Schedule.exponential("100 millis"),
+*   Schedule.recurs(3) // At most 3 retries
+* ])
 *
 * // Allow ten recurrences after the initial run
 * const tenRecurrences = Effect.gen(function*() {
@@ -38391,150 +37878,17 @@ var passthrough$2 = (self) => fromStep(map$23(toStep(self), (step) => (now, inpu
 *
 * // The schedule outputs the current recurrence count (0-based)
 * const countingSchedule = Schedule.recurs(3).pipe(
-*   Schedule.tapOutput((count) => Console.log(`Execution #${count + 1}`))
+*   Schedule.tap(({ output: count }) => Console.log(`Execution #${count + 1}`))
 * )
 * ```
 *
-* @see {@link take} for limiting an existing schedule
+* @see {@link upTo} for limiting an existing schedule
 *
 * @category constructors
 * @since 2.0.0
 */
 var recurs = (times) => while_(forever$3, ({ attempt }) => succeed$11(attempt <= times));
 /**
-* Returns a new `Schedule` that combines the outputs of the provided schedule
-* using the specified effectful `combine` function and starting from the
-* specified `initial` state.
-*
-* **Example** (Reducing schedule outputs)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Sum up execution counts from a counter schedule
-* const sumSchedule = Schedule.reduce(
-*   Schedule.recurs(5),
-*   () => 0, // Initial sum
-*   (sum, count) => Effect.succeed(sum + count) // Add each count to the sum
-* )
-*
-* const sumProgram = Effect.gen(function*() {
-*   const finalSum = yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "task"
-*     }),
-*     sumSchedule.pipe(
-*       Schedule.tapOutput((sum) => Console.log(`Running sum: ${sum}`))
-*     )
-*   )
-*
-*   yield* Console.log(`Final sum: ${finalSum}`)
-* })
-*
-* // Build a history of execution counts
-* const historySchedule = Schedule.reduce(
-*   Schedule.spaced("1 second").pipe(Schedule.take(4)),
-*   () => [] as Array<number>, // Initial empty array
-*   (history, executionNumber) => Effect.succeed([...history, executionNumber])
-* )
-*
-* const historyProgram = Effect.gen(function*() {
-*   const timeline = yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Recording execution...")
-*       return "recorded"
-*     }),
-*     historySchedule
-*   )
-*
-*   yield* Console.log(
-*     `Execution timeline: ${timeline.join(", ")}`
-*   )
-* })
-*
-* // Accumulate metrics with effectful combination
-* const metricsAccumulator = Schedule.reduce(
-*   Schedule.recurs(6),
-*   () => ({ total: 0, count: 0, max: 0 }),
-*   (metrics, executionCount) => Effect.succeed({
-*     total: metrics.total + executionCount + 1,
-*     count: metrics.count + 1,
-*     max: Math.max(metrics.max, executionCount + 1)
-*   })
-* )
-*
-* const metricsProgram = Effect.gen(function*() {
-*   const finalMetrics = yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Processing...")
-*       return "processed"
-*     }),
-*     metricsAccumulator
-*   )
-*
-*   const average = finalMetrics.total / finalMetrics.count
-*   yield* Console.log(`Final metrics: ${finalMetrics.count} executions`)
-*   yield* Console.log(
-*     `Average delay: ${average.toFixed(1)}ms, Max delay: ${finalMetrics.max}ms`
-*   )
-* })
-*
-* // Build configuration state over time
-* const configBuilder = Schedule.reduce(
-*   Schedule.fixed("500 millis").pipe(Schedule.take(3)),
-*   () => ({ retries: 1, timeout: 1000, backoff: 100 }),
-*   (config, executionNumber) => Effect.succeed({
-*     retries: config.retries + 1,
-*     timeout: config.timeout * 1.5,
-*     backoff: Math.min(config.backoff * 2, 5000)
-*   })
-* )
-*
-* const configProgram = Effect.gen(function*() {
-*   const finalConfig = yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Updating configuration...")
-*       return "updated"
-*     }),
-*     configBuilder.pipe(
-*       Schedule.tapOutput((config) =>
-*         Console.log(
-*           `Config: retries=${config.retries}, timeout=${config.timeout}ms`
-*         )
-*       )
-*     )
-*   )
-*
-*   yield* Console.log(`Final config: ${JSON.stringify(finalConfig)}`)
-* })
-* ```
-*
-* @category folding
-* @since 2.0.0
-*/
-var reduce$10 = /*#__PURE__*/ dual(3, (self, initial, combine) => fromStep(map$23(toStep(self), (step) => {
-	let state = initial();
-	return (now, input) => matchEffect$1(step(now, input), {
-		onSuccess([output, delay]) {
-			const next = combine(state, output);
-			if (!isEffect$1(next)) {
-				state = next;
-				return succeed$11([next, delay]);
-			}
-			return map$23(next, (nextState) => {
-				state = nextState;
-				return [nextState, delay];
-			});
-		},
-		onFailure: failCause$9,
-		onDone(output) {
-			const next = combine(state, output);
-			return isEffect$1(next) ? flatMap$9(next, done$2) : done$2(next);
-		}
-	});
-})));
-/**
 * Returns a schedule that recurs continuously, each repetition spaced the
 * specified duration from the last run.
 *
@@ -38564,14 +37918,15 @@ var reduce$10 = /*#__PURE__*/ dual(3, (self, initial, combine) => fromStep(map$2
 *   return "Task completed"
 * }).pipe(
 *   Effect.repeat(
-*     Schedule.spaced("1 second").pipe(Schedule.take(5))
+*     Schedule.spaced("1 second").pipe(Schedule.upTo({ times: 5 }))
 *   )
 * )
 *
 * // Simple spaced schedule with limited repetitions
-* const limitedSpaced = Schedule.spaced("100 millis").pipe(
-*   Schedule.both(Schedule.recurs(5)) // at most 5 times
-* )
+* const limitedSpaced = Schedule.max([
+*   Schedule.spaced("100 millis"),
+*   Schedule.recurs(5) // at most 5 times
+* ])
 *
 * const program = Effect.gen(function*() {
 *   yield* Console.log("Starting spaced execution...")
@@ -38610,7 +37965,7 @@ var spaced = (duration) => {
 * import { Console, Effect, Schedule } from "effect"
 *
 * const monitoredSchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.take(5),
+*   Schedule.upTo({ times: 5 }),
 *   Schedule.tap((metadata) =>
 *     Console.log(
 *       `Attempt ${metadata.attempt} produced ${metadata.output} ` +
@@ -38637,235 +37992,27 @@ var tap$3 = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self), (st
 	}));
 })));
 /**
-* Returns a new `Schedule` that allows execution of an effectful function for
-* every input to the schedule, but does not alter the inputs and outputs of
-* the schedule.
-*
-* **Example** (Tapping retry inputs)
-*
-* ```ts
-* import { Console, Data, Effect, Schedule } from "effect"
-*
-* class RetryError extends Data.TaggedError("RetryError")<{ readonly message: string }> {}
-*
-* // Log retry errors for debugging
-* const errorLoggingSchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.take(3),
-*   Schedule.tapInput((error: RetryError) =>
-*     Console.log(`Retry triggered by error: ${String(error)}`)
-*   )
-* )
-*
-* const retryProgram = Effect.gen(function*() {
-*   let attempt = 0
-*
-*   const result = yield* Effect.retry(
-*     Effect.gen(function*() {
-*       attempt++
-*       if (attempt < 4) {
-*         return yield* Effect.fail(new RetryError({ message: `Network timeout on attempt ${attempt}` }))
-*       }
-*       return `Success on attempt ${attempt}`
-*     }),
-*     errorLoggingSchedule
-*   )
-*
-*   yield* Console.log(`Final result: ${result}`)
-* })
-*
-* // Monitor input frequency for metrics
-* const inputMonitoringSchedule = Schedule.spaced("1 second").pipe(
-*   Schedule.take(5),
-*   Schedule.tapInput((input: unknown) =>
-*     Effect.gen(function*() {
-*       yield* Console.log(`Input type: ${typeof input}`)
-*       // In real applications, might send metrics to monitoring system
-*     })
-*   )
-* )
-*
-* // Input validation with side effects
-* const validatingSchedule = Schedule.fixed("500 millis").pipe(
-*   Schedule.take(4),
-*   Schedule.tapInput((input: any) =>
-*     Effect.gen(function*() {
-*       if (typeof input === "object" && input !== null) {
-*         yield* Console.log(`Valid object input: ${JSON.stringify(input)}`)
-*       } else {
-*         yield* Console.log(`Warning: Non-object input received: ${input}`)
-*       }
-*     })
-*   )
-* )
-*
-* const validationProgram = Effect.gen(function*() {
-*   let count = 0
-*
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       count++
-*       yield* Console.log("Task with validation")
-*       return { data: `sample-${count}` }
-*     }),
-*     validatingSchedule
-*   )
-* })
-*
-* // Conditional alerting based on input
-* const alertingSchedule = Schedule.exponential("200 millis").pipe(
-*   Schedule.take(6),
-*   Schedule.tapInput((error: RetryError) =>
-*     Effect.gen(function*() {
-*       if (String(error).includes("critical")) {
-*         yield* Console.log(`Critical error: ${String(error)}`)
-*         // In real applications, might trigger alerts or notifications
-*       } else {
-*         yield* Console.log(`Regular error: ${String(error)}`)
-*       }
-*     })
-*   )
-* )
-*
-* const alertProgram = Effect.gen(function*() {
-*   let attempt = 0
-*
-*   yield* Effect.retry(
-*     Effect.gen(function*() {
-*       attempt++
-*       const isCritical = attempt === 3
-*       const errorType = isCritical
-*         ? "critical database failure"
-*         : "temporary network issue"
-*       return yield* Effect.fail(new RetryError({ message: errorType }))
-*     }),
-*     alertingSchedule
-*   ).pipe(
-*     Effect.catch((error: unknown) =>
-*       Console.log(`All retries exhausted: ${String(error)}`)
-*     )
-*   )
-* })
-*
-* // Chain multiple input taps for different purposes
-* const comprehensiveSchedule = Schedule.fibonacci("100 millis").pipe(
-*   Schedule.take(5),
-*   Schedule.tapInput((error: RetryError) =>
-*     Console.log(`Error occurred: ${error._tag}`)
-*   ),
-*   Schedule.tapInput((error: RetryError) =>
-*     String(error).length > 20
-*       ? Console.log("Long error message detected")
-*       : Effect.void
-*   )
-* )
-* ```
-*
-* @category sequencing
-* @since 2.0.0
-*/
-var tapInput = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self), (step) => (now, input) => andThen$2(f(input), step(now, input)))));
-/**
-* Returns a new `Schedule` that allows execution of an effectful function for
-* every output of the schedule, but does not alter the inputs and outputs of
-* the schedule.
-*
-* **Example** (Tapping schedule outputs)
-*
-* ```ts
-* import { Console, Data, Effect, Schedule } from "effect"
-*
-* class RetryAttemptError extends Data.TaggedError("RetryAttemptError")<{ readonly message: string }> {}
-*
-* // Log schedule outputs for debugging/monitoring
-* const monitoredSchedule = Schedule.exponential("100 millis").pipe(
-*   Schedule.take(5),
-*   Schedule.tapOutput((delay) => Console.log(`Next delay will be: ${delay}`))
-* )
-*
-* const retryProgram = Effect.gen(function*() {
-*   let attempt = 0
-*
-*   const result = yield* Effect.retry(
-*     Effect.gen(function*() {
-*       attempt++
-*       if (attempt < 4) {
-*         return yield* Effect.fail(new RetryAttemptError({ message: `Attempt ${attempt} failed` }))
-*       }
-*       return `Success on attempt ${attempt}`
-*     }),
-*     monitoredSchedule
-*   )
-*
-*   yield* Console.log(`Final result: ${result}`)
-* })
-*
-* // Tap output for metrics collection
-* const metricsSchedule = Schedule.spaced("1 second").pipe(
-*   Schedule.take(10),
-*   Schedule.tapOutput((executionCount) =>
-*     Effect.gen(function*() {
-*       // Simulate metrics collection
-*       yield* Console.log(`Recording metric: execution_count=${executionCount}`)
-*       // In real code, this might send to monitoring system
-*     })
-*   )
-* )
-*
-* // Tap output with conditional side effects
-* const alertingSchedule = Schedule.fibonacci("200 millis").pipe(
-*   Schedule.take(8),
-*   Schedule.tapOutput((delay) =>
-*     Effect.gen(function*() {
-*       const delayMs = delay.toString()
-*       if (delayMs.includes("1000")) { // Alert on delays >= 1 second
-*         yield* Console.log(`High delay detected: ${delay}`)
-*       }
-*     })
-*   )
-* )
-*
-* const healthCheckProgram = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Performing health check...")
-*       return "healthy"
-*     }),
-*     alertingSchedule
-*   )
-* })
-*
-* // Chain multiple taps for different purposes
-* const comprehensiveSchedule = Schedule.fixed("500 millis").pipe(
-*   Schedule.take(6),
-*   Schedule.tapOutput((count) => Console.log(`Execution ${count + 1}`)),
-*   Schedule.tapOutput((count) =>
-*     count % 3 === 0
-*       ? Console.log("Checkpoint reached")
-*       : Effect.void
-*   )
-* )
-* ```
-*
-* @category sequencing
-* @since 2.0.0
-*/
-var tapOutput = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self), (step) => (now, input) => tap$5(step(now, input), ([output]) => f(output)))));
-/**
-* Returns a new `Schedule` that takes at most the specified number of outputs
-* from the schedule. Once the specified number of outputs is reached, the
-* schedule will stop.
+* Returns a new `Schedule` that limits an existing schedule by elapsed
+* duration, number of outputs, or both.
 *
 * **When to use**
 *
-* Use to limit an existing schedule while preserving its output and delay behavior.
+* Use to bound an existing schedule while preserving its output and delay
+* behavior. When both `duration` and `times` are specified, the schedule
+* stops as soon as either limit is reached.
 *
 * **Gotchas**
 *
-* `take(n)` limits schedule outputs. When used with repeat or retry, the
-* effect is evaluated once before the schedule is stepped, so the total number
-* of evaluations can be one greater than the number of outputs taken.
+* The `times` option limits schedule outputs. When used with repeat or retry,
+* the effect is evaluated once before the schedule is stepped, so the total
+* number of evaluations can be one greater than the configured number of
+* outputs.
+*
+* The `duration` option is based on the elapsed time observed by the schedule
+* step. Long-running effects can cause the duration limit to be detected on the
+* following schedule step.
 *
-* **Example** (Taking a limited number of recurrences)
+* **Example** (Limiting by duration and recurrence count)
 *
 * ```ts
 * import { Console, Data, Effect, Schedule } from "effect"
@@ -38874,7 +38021,7 @@ var tapOutput = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self),
 *
 * // Limit an infinite schedule to five recurrences
 * const limitedHeartbeat = Schedule.spaced("1 second").pipe(
-*   Schedule.take(5) // Will stop after 5 schedule outputs
+*   Schedule.upTo({ times: 5 })
 * )
 *
 * const heartbeatProgram = Effect.gen(function*() {
@@ -38889,9 +38036,12 @@ var tapOutput = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self),
 *   yield* Console.log("Heartbeat sequence completed")
 * })
 *
-* // Limit retry attempts to a specific number
+* // Limit retry attempts by both count and elapsed time
 * const limitedRetry = Schedule.exponential("100 millis").pipe(
-*   Schedule.take(3) // At most 3 retry attempts
+*   Schedule.upTo({
+*     duration: "5 seconds",
+*     times: 3
+*   })
 * )
 *
 * const retryProgram = Effect.gen(function*() {
@@ -38918,136 +38068,19 @@ var tapOutput = /*#__PURE__*/ dual(2, (self, f) => fromStep(map$23(toStep(self),
 *   )
 * )
 *
-* // Combine take with other schedule operations
-* const samplingSchedule = Schedule.fixed("500 millis").pipe(
-*   Schedule.take(10), // Take at most 10 schedule outputs
-*   Schedule.map((count) => Effect.succeed(`Sample #${count + 1}`))
+* // Empty options leave the schedule unchanged
+* const unchanged = Schedule.fixed("500 millis").pipe(
+*   Schedule.upTo({})
 * )
-*
-* const samplingProgram = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       const value = "sample"
-*       yield* Console.log(`Sampled value: ${value}`)
-*       return value
-*     }),
-*     samplingSchedule.pipe(
-*       Schedule.tapOutput((label) => Console.log(`Completed: ${label}`))
-*     )
-*   )
-* })
 * ```
 *
-* @see {@link recurs} for creating a count-limited schedule
-*
-* @category taking
+* @category filtering
 * @since 4.0.0
 */
-var take$11 = /*#__PURE__*/ dual(2, (self, n) => while_(self, ({ attempt }) => succeed$11(attempt <= n)));
-/**
-* Creates a schedule that unfolds a state by repeatedly applying a function,
-* outputting the current state and computing the next state.
-*
-* **Example** (Unfolding schedule state)
-*
-* ```ts
-* import { Console, Effect, Schedule } from "effect"
-*
-* // Counter schedule that increments by 1 each time
-* const counterSchedule = Schedule.unfold(0, (n) => Effect.succeed(n + 1))
-* // Outputs: 0, 1, 2, 3, 4, 5, ...
-*
-* const countingProgram = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("Task executed")
-*       return "done"
-*     }),
-*     counterSchedule.pipe(
-*       Schedule.take(5),
-*       Schedule.tapOutput((count) => Console.log(`Count: ${count}`))
-*     )
-*   )
-* })
-*
-* // Fibonacci sequence schedule
-* const fibonacciSchedule = Schedule.unfold(
-*   [0, 1] as [number, number],
-*   ([a, b]) => Effect.succeed([b, a + b] as [number, number])
-* )
-* // Outputs: [0,1], [1,1], [1,2], [2,3], [3,5], [5,8], ...
-*
-* const fibProgram = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Console.log("Fibonacci step"),
-*     fibonacciSchedule.pipe(
-*       Schedule.take(8),
-*       Schedule.tapOutput(([a, b]) => Console.log(`Fib: ${a}, next: ${b}`))
-*     )
-*   )
-* })
-*
-* // Effectful unfold - exponential backoff with state
-* const exponentialState = Schedule.unfold(
-*   100,
-*   (delayMs) =>
-*     Effect.gen(function*() {
-*       yield* Console.log(`Current delay: ${delayMs}ms`)
-*       return Math.min(delayMs * 2, 5000) // Cap at 5 seconds
-*     })
-* )
-*
-* // Deterministic delay adjustment schedule
-* const adjustedDelaySchedule = Schedule.unfold(
-*   { delay: 1000, adjustment: 100 },
-*   ({ delay, adjustment }) =>
-*     Effect.gen(function*() {
-*       const nextDelay = Math.max(100, delay + adjustment)
-*       yield* Console.log(`Adjusted delay: ${nextDelay}ms`)
-*       return { delay: nextDelay, adjustment: adjustment * -1 }
-*     })
-* )
-*
-* // State machine schedule
-* type State = "init" | "warming" | "active" | "cooling"
-* const stateMachineSchedule = Schedule.unfold("init" as State, (state) => {
-*   switch (state) {
-*     case "init":
-*       return Effect.succeed("warming" as State)
-*     case "warming":
-*       return Effect.succeed("active" as State)
-*     case "active":
-*       return Effect.succeed("cooling" as State)
-*     case "cooling":
-*       return Effect.succeed("active" as State)
-*   }
-* })
-*
-* const stateMachineProgram = Effect.gen(function*() {
-*   yield* Effect.repeat(
-*     Effect.gen(function*() {
-*       yield* Console.log("State machine step")
-*       return "step"
-*     }),
-*     stateMachineSchedule.pipe(
-*       Schedule.take(10),
-*       Schedule.tapOutput((state) => Console.log(`State: ${state}`))
-*     )
-*   )
-* })
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-var unfold$1 = (initial, next) => fromStep(sync$6(() => {
-	let state = initial;
-	return constant$2(map$23(suspend$6(() => next(state)), (nextState) => {
-		const prev = state;
-		state = nextState;
-		return [prev, zero];
-	}));
-}));
+var upTo = /*#__PURE__*/ dual(2, (self, options) => {
+	const duration = options.duration === void 0 ? void 0 : fromInputUnsafe(options.duration);
+	return while_(self, ({ attempt, elapsed }) => succeed$11((options.times === void 0 || attempt <= options.times) && (duration === void 0 || isLessThanOrEqualTo$5(millis(elapsed), duration))));
+});
 var while_ = /*#__PURE__*/ dual(2, (self, predicate) => fromStep(map$23(toStep(self), (step) => {
 	const meta = metadataFn();
 	return (now, input) => flatMap$9(step(now, input), (result) => {
@@ -39089,7 +38122,7 @@ var while_ = /*#__PURE__*/ dual(2, (self, predicate) => fromStep(map$23(toStep(s
 *       yield* Console.log("Window task executed")
 *       return "window-task"
 *     }),
-*     windowSchedule.pipe(Schedule.take(4))
+*     windowSchedule.pipe(Schedule.upTo({ times: 4 }))
 *   )
 * })
 * ```
@@ -39123,7 +38156,7 @@ var windowed = (interval) => {
 *       yield* Console.log("Running forever...")
 *       return "continuous-task"
 *     }),
-*     infiniteSchedule.pipe(Schedule.take(5)) // Limit for demo
+*     infiniteSchedule.pipe(Schedule.upTo({ times: 5 })) // Limit for demo
 *   )
 * })
 * ```
@@ -39135,37 +38168,6 @@ var forever$3 = /*#__PURE__*/ spaced(zero);
 var constIdentity = /*#__PURE__*/ fromStep(/*#__PURE__*/ succeed$11((_now, input) => succeed$11([input, zero])));
 var identity_ = () => constIdentity;
 /**
-* Ensures that a schedule's input type extends a given type `T`.
-*
-* **When to use**
-*
-* Use when you need a generic helper to prove that an existing schedule can
-* consume a required input type without changing runtime behavior.
-*
-* **Example** (Constraining schedule input types)
-*
-* ```ts
-* import { Schedule } from "effect"
-*
-* declare const StringInputSchedule: Schedule.Schedule<number, string>
-* declare const NumberInputSchedule: Schedule.Schedule<number, number>
-*
-* const satisfiesStringInput = Schedule.satisfiesInputType<string>()
-*
-* // This works because the schedule input type is string.
-* const validSchedule = satisfiesStringInput(StringInputSchedule)
-*
-* // This would cause a TypeScript compilation error:
-* // const invalidSchedule = satisfiesStringInput(NumberInputSchedule)
-* ```
-*
-* @see {@link setInputType} for adapting an input-agnostic schedule
-*
-* @category utility types
-* @since 4.0.0
-*/
-var satisfiesInputType = () => (self) => self;
-/**
 * Sets the input type of the provided schedule without altering its behavior.
 *
 * **When to use**
@@ -39187,108 +38189,10 @@ var satisfiesInputType = () => (self) => self;
 * )
 * ```
 *
-* @see {@link satisfiesInputType} for checking an existing input type
-*
 * @category utility types
 * @since 4.0.0
 */
 var setInputType = () => (self) => self;
-/**
-* Ensures that a schedule's output type extends a given type `T`.
-*
-* **Details**
-*
-* This helper is checked at compile time and does not change the schedule's
-* runtime behavior.
-*
-* **Example** (Constraining schedule output types)
-*
-* ```ts
-* import { Schedule } from "effect"
-*
-* declare const StringOutputSchedule: Schedule.Schedule<string>
-* declare const NumberOutputSchedule: Schedule.Schedule<number>
-*
-* const satisfiesStringOutput = Schedule.satisfiesOutputType<string>()
-*
-* // This works because the schedule output type is string.
-* const validSchedule = satisfiesStringOutput(StringOutputSchedule)
-*
-* // This would cause a TypeScript compilation error:
-* // const invalidSchedule = satisfiesStringOutput(NumberOutputSchedule)
-* ```
-*
-* @category utility types
-* @since 4.0.0
-*/
-var satisfiesOutputType = () => (self) => self;
-/**
-* Ensures that a schedule's error type extends a given type `T`.
-*
-* **Details**
-*
-* This helper is checked at compile time and does not change the schedule's
-* runtime behavior.
-*
-* **Example** (Constraining schedule error types)
-*
-* ```ts
-* import { Data, Schedule } from "effect"
-*
-* // Create a custom error using Data.TaggedError
-* class CustomError extends Data.TaggedError("CustomError")<{
-*   message: string
-* }> {}
-*
-* declare const CustomErrorSchedule: Schedule.Schedule<number, unknown, CustomError>
-* declare const StringErrorSchedule: Schedule.Schedule<number, unknown, string>
-*
-* const satisfiesCustomError = Schedule.satisfiesErrorType<CustomError>()
-*
-* // This works because the schedule error type is CustomError.
-* const validSchedule = satisfiesCustomError(CustomErrorSchedule)
-*
-* // This would cause a TypeScript compilation error:
-* // const invalidSchedule = satisfiesCustomError(StringErrorSchedule)
-* ```
-*
-* @category utility types
-* @since 4.0.0
-*/
-var satisfiesErrorType$1 = () => (self) => self;
-/**
-* Ensures that a schedule's context type extends a given type `T`.
-*
-* **Details**
-*
-* This helper is checked at compile time and does not change the schedule's
-* runtime behavior.
-*
-* **Example** (Constraining schedule service types)
-*
-* ```ts
-* import { Schedule } from "effect"
-*
-* interface Logger {
-*   readonly log: (message: string) => void
-* }
-*
-* declare const LoggerSchedule: Schedule.Schedule<number, unknown, never, Logger>
-* declare const NumberSchedule: Schedule.Schedule<number, unknown, never, number>
-*
-* const satisfiesLogger = Schedule.satisfiesServicesType<Logger>()
-*
-* // This works because the schedule context type is Logger.
-* const validSchedule = satisfiesLogger(LoggerSchedule)
-*
-* // This would cause a TypeScript compilation error:
-* // const invalidSchedule = satisfiesLogger(NumberSchedule)
-* ```
-*
-* @category utility types
-* @since 4.0.0
-*/
-var satisfiesServicesType$1 = () => (self) => self;
 //#endregion
 //#region ../../node_modules/effect/dist/internal/layer.js
 var provideLayer = (self, layer, options) => scopedWith$1((scope) => flatMap$9(options?.local ? buildWithMemoMap(layer, makeMemoMapUnsafe(), scope) : buildWithScope(layer, scope), (context) => provideContext$4(self, context)));
@@ -42104,6 +41008,7 @@ var Effect_exports = /* @__PURE__ */ __exportAll({
 	scopedWith: () => scopedWith,
 	service: () => service$1,
 	serviceOption: () => serviceOption$1,
+	setContext: () => setContext,
 	sleep: () => sleep,
 	spanAnnotations: () => spanAnnotations,
 	spanLinks: () => spanLinks,
@@ -46257,6 +45162,49 @@ var provide$3 = provide$4;
 */
 var provideContext$3 = provideContext$4;
 /**
+* Runs an effect with the provided context as its complete environment.
+*
+* **When to use**
+*
+* Use when you already have a `Context` containing every service required by
+* the effect and want the wrapped effect to run with exactly that context.
+*
+* **Gotchas**
+*
+* `setContext` replaces the current context for the wrapped effect. Services
+* from an outer context are not inherited unless they are also present in the
+* context passed to `setContext`.
+*
+* **Example** (Running with a complete context)
+*
+* ```ts
+* import { Context, Effect } from "effect"
+*
+* class Config extends Context.Service<Config, {
+*   readonly greeting: string
+* }>()("Config") {}
+*
+* const program = Effect.gen(function*() {
+*   const config = yield* Effect.service(Config)
+*   return `${config.greeting}, World!`
+* })
+*
+* const context = Context.make(Config, { greeting: "Hello" })
+*
+* const runnable = Effect.setContext(program, context)
+*
+* Effect.runPromise(runnable).then(console.log)
+* // Output: "Hello, World!"
+* ```
+*
+* @see {@link provideContext} for partially satisfying an effect's context requirements.
+* @see {@link updateContext} for deriving the required context from the current one.
+*
+* @category environment
+* @since 4.0.0
+*/
+var setContext = setContext$1;
+/**
 * Accesses a service from the context.
 *
 * **Example** (Accessing a required service)
@@ -52376,7 +51324,7 @@ var distance = distance$1;
 * @category comparisons
 * @since 3.6.0
 */
-var min$1 = min$3;
+var min$1 = min$4;
 /**
 * Returns the later of two `DateTime` values.
 *
@@ -52395,7 +51343,7 @@ var min$1 = min$3;
 * @category comparisons
 * @since 3.6.0
 */
-var max$1 = max$3;
+var max$1 = max$4;
 /**
 * Checks whether the first `DateTime` is after the second `DateTime`.
 *
@@ -56298,6 +55246,7 @@ var SchemaTransformation_exports = /* @__PURE__ */ __exportAll({
 	bigDecimalFromString: () => bigDecimalFromString,
 	bigintFromString: () => bigintFromString,
 	capitalize: () => capitalize,
+	dateFromMillis: () => dateFromMillis,
 	dateFromString: () => dateFromString,
 	dateTimeUtcFromString: () => dateTimeUtcFromString,
 	dateTimeZonedFromString: () => dateTimeZonedFromString,
@@ -56993,7 +55942,7 @@ var bigintFromString = /*#__PURE__*/ new Transformation(/*#__PURE__*/ BigInt$3()
 * )
 * ```
 *
-* @see {@link numberFromString}
+* @see {@link dateFromMillis}
 * @see {@link dateTimeUtcFromString}
 *
 * @category Coercions
@@ -57001,6 +55950,42 @@ var bigintFromString = /*#__PURE__*/ new Transformation(/*#__PURE__*/ BigInt$3()
 */
 var dateFromString = /*#__PURE__*/ new Transformation(/*#__PURE__*/ Date$2(), /*#__PURE__*/ transform$1(formatDate));
 /**
+* Decodes epoch milliseconds into a `Date` and encodes a `Date` back to epoch
+* milliseconds.
+*
+* **When to use**
+*
+* Use when you need a schema transformation for numeric timestamps represented
+* as milliseconds since the Unix epoch.
+*
+* **Details**
+*
+* Decoding creates a `Date` from the number like `new Date(ms)`. Encoding
+* returns the `Date` timestamp like `date.getTime()`.
+*
+* **Gotchas**
+*
+* This transformation does not validate date validity. `NaN`, `Infinity`, and
+* `-Infinity` decode to invalid `Date` instances.
+*
+* **Example** (Converting milliseconds to a Date)
+*
+* ```ts
+* import { Schema, SchemaTransformation } from "effect"
+*
+* const schema = Schema.Number.pipe(
+*   Schema.decodeTo(Schema.Date, SchemaTransformation.dateFromMillis)
+* )
+* ```
+*
+* @see {@link dateFromString}
+* @see {@link SchemaGetter.dateTimeUtcFromInput}
+*
+* @category Coercions
+* @since 4.0.0
+*/
+var dateFromMillis = /*#__PURE__*/ new Transformation(/*#__PURE__*/ Date$2(), /*#__PURE__*/ transform$1((date) => date.getTime()));
+/**
 * Decodes a `string` into a `Duration` and encodes a `Duration` back to a
 * parseable `string`.
 *
@@ -57773,8 +56758,8 @@ var timeZoneFromString = /*#__PURE__*/ transformOrFail({
 * UTC, and fails with `InvalidValue` when parsing fails. Encode uses
 * `DateTime.formatIso`.
 *
-* @see {@link dateTimeZonedFromString} for ISO strings that should preserve zoned date-time information
 * @see {@link dateFromString} for decoding into JavaScript `Date`
+* @see {@link dateTimeZonedFromString} for ISO strings that should preserve zoned date-time information
 *
 * @category transforming
 * @since 4.0.0
@@ -64841,7 +63826,7 @@ var join$5 = join$6;
 * @category folding
 * @since 2.0.0
 */
-var reduce$9 = reduce$11;
+var reduce$9 = reduce$10;
 /**
 * Reduces the elements of a chunk from right to left.
 *
@@ -83248,17 +82233,39 @@ var ChainArbitrary = class extends Arbitrary {
 	}
 };
 /** @internal */
+function mapperWithCloneIfNeeded(v, mapper) {
+	const sourceValue = v.value;
+	const mappedValue = mapper(sourceValue);
+	if (v.hasToBeCloned && (typeof mappedValue === "object" && mappedValue !== null || typeof mappedValue === "function") && Object.isExtensible(mappedValue) && !hasCloneMethod(mappedValue)) Object.defineProperty(mappedValue, cloneMethod, { get: () => () => mapperWithCloneIfNeeded(v, mapper)[0] });
+	return [mappedValue, sourceValue];
+}
+/** @internal */
+function valueMapper(v, mapper) {
+	const [mappedValue, sourceValue] = mapperWithCloneIfNeeded(v, mapper);
+	return new Value(mappedValue, {
+		originalValue: sourceValue,
+		originalContext: v.context
+	});
+}
+/** @internal */
 var MapArbitrary = class extends Arbitrary {
 	constructor(arb, mapper, unmapper) {
 		super();
 		this.arb = arb;
 		this.mapper = mapper;
 		this.unmapper = unmapper;
-		this.bindValueMapper = (v) => this.valueMapper(v);
+		this.bindValueMapper = (v) => valueMapper(v, mapper);
 	}
 	generate(mrng, biasFactor) {
 		const g = this.arb.generate(mrng, biasFactor);
-		return this.valueMapper(g);
+		if (!g.hasToBeCloned) {
+			const sourceValue = g.value;
+			return new Value(this.mapper(sourceValue), {
+				originalValue: sourceValue,
+				originalContext: g.context
+			});
+		}
+		return valueMapper(g, this.mapper);
 	}
 	canShrinkWithoutContext(value) {
 		if (this.unmapper !== void 0) try {
@@ -83277,19 +82284,6 @@ var MapArbitrary = class extends Arbitrary {
 		}
 		return Stream.nil();
 	}
-	mapperWithCloneIfNeeded(v) {
-		const sourceValue = v.value;
-		const mappedValue = this.mapper(sourceValue);
-		if (v.hasToBeCloned && (typeof mappedValue === "object" && mappedValue !== null || typeof mappedValue === "function") && Object.isExtensible(mappedValue) && !hasCloneMethod(mappedValue)) Object.defineProperty(mappedValue, cloneMethod, { get: () => () => this.mapperWithCloneIfNeeded(v)[0] });
-		return [mappedValue, sourceValue];
-	}
-	valueMapper(v) {
-		const [mappedValue, sourceValue] = this.mapperWithCloneIfNeeded(v);
-		return new Value(mappedValue, {
-			originalValue: sourceValue,
-			originalContext: v.context
-		});
-	}
 	isSafeContext(context) {
 		return context !== null && context !== void 0 && typeof context === "object" && "originalValue" in context && "originalContext" in context;
 	}
@@ -83815,40 +82809,39 @@ function makeLazy(producer) {
 var safeArrayIsArray$4 = Array.isArray;
 var safeObjectDefineProperty$3 = Object.defineProperty;
 /** @internal */
-function tupleMakeItCloneable(vs, values) {
+function tupleMakeItCloneable(vs, ctxs, values) {
 	return safeObjectDefineProperty$3(vs, cloneMethod, { value: () => {
 		const cloned = [];
-		for (let idx = 0; idx !== values.length; ++idx) safePush(cloned, values[idx].value);
-		tupleMakeItCloneable(cloned, values);
+		for (let idx = 0; idx !== values.length; ++idx) {
+			let current = values[idx];
+			if (current === void 0) current = new Value(vs[idx], ctxs[idx]);
+			safePush(cloned, current.value);
+		}
+		tupleMakeItCloneable(cloned, ctxs, values);
 		return cloned;
 	} });
 }
 /** @internal */
-function tupleWrapper(values) {
-	let cloneable = false;
-	const vs = [];
-	const ctxs = [];
-	for (let idx = 0; idx !== values.length; ++idx) {
-		const v = values[idx];
-		cloneable = cloneable || v.hasToBeCloned;
-		safePush(vs, v.value);
-		safePush(ctxs, v.context);
-	}
-	if (cloneable) tupleMakeItCloneable(vs, values);
-	return new Value(vs, ctxs);
-}
-/** @internal */
 function tupleShrink(arbs, value, context) {
 	const shrinks = [];
 	const safeContext = safeArrayIsArray$4(context) ? context : [];
 	for (let idx = 0; idx !== arbs.length; ++idx) safePush(shrinks, makeLazy(() => arbs[idx].shrink(value[idx], safeContext[idx]).map((v) => {
-		const nextValues = safeMap(value, (v, idx) => new Value(cloneIfNeeded(v), safeContext[idx]));
-		return [
-			...safeSlice(nextValues, 0, idx),
-			v,
-			...safeSlice(nextValues, idx + 1)
-		];
-	}).map(tupleWrapper)));
+		let cloneable = false;
+		const vs = [];
+		const ctxs = [];
+		const mapped = [];
+		for (let nestedIdx = 0; nestedIdx !== arbs.length; ++nestedIdx) {
+			const nestedV = nestedIdx === idx ? v : new Value(cloneIfNeeded(value[nestedIdx]), safeContext[nestedIdx]);
+			if (nestedV.hasToBeCloned) {
+				cloneable = true;
+				mapped[nestedIdx] = nestedV;
+			}
+			safePush(vs, nestedV.value);
+			safePush(ctxs, nestedV.context);
+		}
+		if (cloneable) tupleMakeItCloneable(vs, ctxs, mapped);
+		return new Value(vs, ctxs);
+	})));
 	return Stream.nil().join(...shrinks);
 }
 /** @internal */
@@ -83862,9 +82855,21 @@ var TupleArbitrary = class extends Arbitrary {
 		}
 	}
 	generate(mrng, biasFactor) {
+		let cloneable = false;
+		const vs = [];
+		const ctxs = [];
 		const mapped = [];
-		for (let idx = 0; idx !== this.arbs.length; ++idx) safePush(mapped, this.arbs[idx].generate(mrng, biasFactor));
-		return tupleWrapper(mapped);
+		for (let idx = 0; idx !== this.arbs.length; ++idx) {
+			const v = this.arbs[idx].generate(mrng, biasFactor);
+			if (v.hasToBeCloned) {
+				cloneable = true;
+				mapped[idx] = v;
+			}
+			safePush(vs, v.value);
+			safePush(ctxs, v.context);
+		}
+		if (cloneable) tupleMakeItCloneable(vs, ctxs, mapped);
+		return new Value(vs, ctxs);
 	}
 	canShrinkWithoutContext(value) {
 		if (!safeArrayIsArray$4(value) || value.length !== this.arbs.length) return false;
@@ -85066,7 +84071,7 @@ function pathWalk(path, initialProducers, shrink) {
 	}
 	return values;
 }
-var safeObjectAssign$5 = Object.assign;
+var safeObjectAssign$6 = Object.assign;
 /** @internal */
 function formatHints(hints) {
 	if (hints.length === 1) return `Hint: ${hints[0]}`;
@@ -85187,7 +84192,7 @@ async function asyncDefaultReportMessage(out) {
 function buildError(errorMessage, out) {
 	if (out.runConfiguration.includeErrorInReport) throw new SError(errorMessage);
 	const error = new SError(errorMessage, { cause: out.errorInstance });
-	if (!("cause" in error)) safeObjectAssign$5(error, { cause: out.errorInstance });
+	if (!("cause" in error)) safeObjectAssign$6(error, { cause: out.errorInstance });
 	return error;
 }
 /** @internal */
@@ -85349,7 +84354,7 @@ function statistics(generator, classify, params) {
 	const longestPercent = data.map((i) => i[1].length).reduce((p, c) => Math.max(p, c), 0);
 	for (const item of data) qParams.logger(`${item[0].padEnd(longestName, ".")}..${item[1].padStart(longestPercent, ".")}`);
 }
-var safeObjectAssign$4 = Object.assign;
+var safeObjectAssign$5 = Object.assign;
 /**
 * An internal builder of values of type {@link GeneratorValue}
 * @internal
@@ -85387,7 +84392,7 @@ function buildGeneratorValue(mrng, biasFactor, computePreBuiltValues, arbitraryC
 	const memoedValueFunction = (arb, ...args) => {
 		return valueFunction(arbitraryCache(arb, args));
 	};
-	return new Value(safeObjectAssign$4(memoedValueFunction, {
+	return new Value(safeObjectAssign$5(memoedValueFunction, {
 		values() {
 			return safeMap(context.history, (c) => c.value);
 		},
@@ -85601,33 +84606,27 @@ var IntegerArbitrary = class IntegerArbitrary extends Arbitrary {
 		super();
 		this.min = min;
 		this.max = max;
+		this.ranges = biasNumericRange(min, max, integerLogLike);
 	}
 	generate(mrng, biasFactor) {
-		const range = this.computeGenerateRange(mrng, biasFactor);
+		if (biasFactor === void 0 || mrng.nextInt(1, biasFactor) !== 1) return new Value(mrng.nextInt(this.min, this.max), void 0);
+		const ranges = this.ranges;
+		if (ranges.length === 1) {
+			const range = ranges[0];
+			return new Value(mrng.nextInt(range.min, range.max), void 0);
+		}
+		const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
+		const range = id < 0 ? ranges[0] : ranges[id + 1];
 		return new Value(mrng.nextInt(range.min, range.max), void 0);
 	}
 	canShrinkWithoutContext(value) {
 		return typeof value === "number" && safeNumberIsInteger$6(value) && !safeObjectIs$6(value, -0) && this.min <= value && value <= this.max;
 	}
 	shrink(current, context) {
-		if (!IntegerArbitrary.isValidContext(current, context)) return shrinkInteger(current, this.defaultTarget(), true);
+		if (!IntegerArbitrary.isValidContext(current, context)) return shrinkInteger(current, this.min <= 0 && this.max >= 0 ? 0 : this.min < 0 ? this.max : this.min, true);
 		if (this.isLastChanceTry(current, context)) return Stream.of(new Value(context, void 0));
 		return shrinkInteger(current, context, false);
 	}
-	defaultTarget() {
-		if (this.min <= 0 && this.max >= 0) return 0;
-		return this.min < 0 ? this.max : this.min;
-	}
-	computeGenerateRange(mrng, biasFactor) {
-		if (biasFactor === void 0 || mrng.nextInt(1, biasFactor) !== 1) return {
-			min: this.min,
-			max: this.max
-		};
-		const ranges = biasNumericRange(this.min, this.max, integerLogLike);
-		if (ranges.length === 1) return ranges[0];
-		const id = mrng.nextInt(-2 * (ranges.length - 1), ranges.length - 2);
-		return id < 0 ? ranges[0] : ranges[id + 1];
-	}
 	isLastChanceTry(current, context) {
 		if (current > 0) return current === context + 1 && current > this.min;
 		if (current < 0) return current === context - 1 && current < this.max;
@@ -85706,7 +84705,7 @@ var NoopSlicedGenerator = class {
 	}
 };
 var safeMathMin$5 = Math.min;
-var safeMathMax$3 = Math.max;
+var safeMathMax$2 = Math.max;
 /** @internal */
 var SlicedBasedGenerator = class {
 	constructor(arb, mrng, slices, biasFactor) {
@@ -85741,7 +84740,7 @@ var SlicedBasedGenerator = class {
 		const rangeBoundaryA = this.mrng.nextInt(0, slice.length - 1);
 		const rangeBoundaryB = this.mrng.nextInt(0, slice.length - 1);
 		this.nextIndexInSlice = safeMathMin$5(rangeBoundaryA, rangeBoundaryB);
-		this.lastIndexInSlice = safeMathMax$3(rangeBoundaryA, rangeBoundaryB);
+		this.lastIndexInSlice = safeMathMax$2(rangeBoundaryA, rangeBoundaryB);
 		return new Value(slice[this.nextIndexInSlice++], void 0);
 	}
 };
@@ -85761,7 +84760,6 @@ function buildSlicedGenerator(arb, mrng, slices, biasFactor) {
 }
 var safeMathFloor$4 = Math.floor;
 var safeMathLog$1 = Math.log;
-var safeMathMax$2 = Math.max;
 var safeArrayIsArray$2 = Array.isArray;
 /** @internal */
 function biasedMaxLength(minLength, maxLength) {
@@ -85783,6 +84781,7 @@ var ArrayArbitrary = class ArrayArbitrary extends Arbitrary {
 			max: maxGeneratedLength
 		});
 		this.depthContext = getDepthContextFor(depthIdentifier);
+		this.cachedBiasedMaxLength = biasedMaxLength(minLength, maxGeneratedLength);
 	}
 	preFilter(tab) {
 		if (this.setBuilder === void 0) return tab;
@@ -85811,7 +84810,8 @@ var ArrayArbitrary = class ArrayArbitrary extends Arbitrary {
 		return s.getData();
 	}
 	safeGenerateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems) {
-		const depthImpact = safeMathMax$2(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength));
+		const depthImpact = N - this.cachedBiasedMaxLength;
+		if (depthImpact <= 0) return this.generateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems);
 		this.depthContext.depth += depthImpact;
 		try {
 			return this.generateNItemsNoDuplicates(setBuilder, N, mrng, biasFactorItems);
@@ -85827,7 +84827,8 @@ var ArrayArbitrary = class ArrayArbitrary extends Arbitrary {
 		return items;
 	}
 	safeGenerateNItems(N, mrng, biasFactorItems) {
-		const depthImpact = safeMathMax$2(0, N - biasedMaxLength(this.minLength, this.maxGeneratedLength));
+		const depthImpact = N - this.cachedBiasedMaxLength;
+		if (depthImpact <= 0) return this.generateNItems(N, mrng, biasFactorItems);
 		this.depthContext.depth += depthImpact;
 		try {
 			return this.generateNItems(N, mrng, biasFactorItems);
@@ -85855,30 +84856,26 @@ var ArrayArbitrary = class ArrayArbitrary extends Arbitrary {
 		});
 	}
 	generate(mrng, biasFactor) {
-		const biasMeta = this.applyBias(mrng, biasFactor);
-		const targetSize = biasMeta.size;
-		const items = this.setBuilder !== void 0 ? this.safeGenerateNItemsNoDuplicates(this.setBuilder, targetSize, mrng, biasMeta.biasFactorItems) : this.safeGenerateNItems(targetSize, mrng, biasMeta.biasFactorItems);
-		return this.wrapper(items, false, void 0, 0);
-	}
-	applyBias(mrng, biasFactor) {
-		if (biasFactor === void 0) return { size: this.lengthArb.generate(mrng, void 0).value };
-		if (this.minLength === this.maxGeneratedLength) return {
-			size: this.lengthArb.generate(mrng, void 0).value,
-			biasFactorItems: biasFactor
-		};
-		if (mrng.nextInt(1, biasFactor) !== 1) return { size: this.lengthArb.generate(mrng, void 0).value };
-		if (mrng.nextInt(1, biasFactor) !== 1 || this.minLength === this.maxGeneratedLength) return {
-			size: this.lengthArb.generate(mrng, void 0).value,
-			biasFactorItems: biasFactor
-		};
-		const maxBiasedLength = biasedMaxLength(this.minLength, this.maxGeneratedLength);
-		return {
-			size: integer({
+		let targetSize;
+		let biasFactorItems;
+		if (biasFactor === void 0) targetSize = this.lengthArb.generate(mrng, void 0).value;
+		else if (this.minLength === this.maxGeneratedLength) {
+			targetSize = this.lengthArb.generate(mrng, void 0).value;
+			biasFactorItems = biasFactor;
+		} else if (mrng.nextInt(1, biasFactor) !== 1) targetSize = this.lengthArb.generate(mrng, void 0).value;
+		else if (mrng.nextInt(1, biasFactor) !== 1) {
+			targetSize = this.lengthArb.generate(mrng, void 0).value;
+			biasFactorItems = biasFactor;
+		} else {
+			const maxBiasedLength = this.cachedBiasedMaxLength;
+			targetSize = integer({
 				min: this.minLength,
 				max: maxBiasedLength
-			}).generate(mrng, void 0).value,
-			biasFactorItems: biasFactor
-		};
+			}).generate(mrng, void 0).value;
+			biasFactorItems = biasFactor;
+		}
+		const items = this.setBuilder !== void 0 ? this.safeGenerateNItemsNoDuplicates(this.setBuilder, targetSize, mrng, biasFactorItems) : this.safeGenerateNItems(targetSize, mrng, biasFactorItems);
+		return this.wrapper(items, false, void 0, 0);
 	}
 	canShrinkWithoutContext(value) {
 		if (!safeArrayIsArray$2(value) || this.minLength > value.length || value.length > this.maxLength) return false;
@@ -86712,12 +85709,17 @@ var safeReflectOwnKeys = Reflect.ownKeys;
 /** @internal */
 function keyValuePairsToObjectMapper(definition) {
 	const obj = definition[1] ? safeObjectCreate$5(null) : {};
-	for (const keyValue of definition[0]) safeObjectDefineProperty$2(obj, keyValue[0], {
-		enumerable: true,
-		configurable: true,
-		writable: true,
-		value: keyValue[1]
-	});
+	const keyValues = definition[0];
+	for (let idx = 0; idx !== keyValues.length; ++idx) {
+		const key = keyValues[idx][0];
+		if (key === "__proto__") safeObjectDefineProperty$2(obj, key, {
+			enumerable: true,
+			configurable: true,
+			writable: true,
+			value: keyValues[idx][1]
+		});
+		else obj[key] = keyValues[idx][1];
+	}
 	return obj;
 }
 /** @internal */
@@ -86767,11 +85769,12 @@ var FrequencyArbitrary = class FrequencyArbitrary extends Arbitrary {
 			if (currentWeight < 0) throw new Error(`${label} expects weights to be superior or equal to 0`);
 		}
 		if (totalWeight <= 0) throw new Error(`${label} expects the sum of weights to be strictly superior to 0`);
-		return new FrequencyArbitrary(warbs, {
+		const sanitizedConstraints = {
 			depthBias: depthBiasFromSizeForArbitrary(constraints.depthSize, constraints.maxDepth !== void 0),
 			maxDepth: constraints.maxDepth !== void 0 ? constraints.maxDepth : safePositiveInfinity$7,
 			withCrossShrink: !!constraints.withCrossShrink
-		}, getDepthContextFor(constraints.depthIdentifier));
+		};
+		return new FrequencyArbitrary(warbs, sanitizedConstraints, getDepthContextFor(constraints.depthIdentifier));
 	}
 	constructor(warbs, constraints, context) {
 		super();
@@ -89233,7 +88236,7 @@ function noShrink(arb) {
 	if (stableObjectGetPrototypeOf(arb) === NoShrinkArbitrary.prototype && arb.generate === NoShrinkArbitrary.prototype.generate && arb.canShrinkWithoutContext === NoShrinkArbitrary.prototype.canShrinkWithoutContext && arb.shrink === NoShrinkArbitrary.prototype.shrink) return arb;
 	return new NoShrinkArbitrary(arb);
 }
-var safeObjectAssign$3 = Object.assign;
+var safeObjectAssign$4 = Object.assign;
 var safeObjectKeys$3 = Object.keys;
 /** @internal */
 function buildCompareFunctionArbitrary(cmp) {
@@ -89250,7 +88253,7 @@ function buildCompareFunctionArbitrary(cmp) {
 				recorded[`[${reprA},${reprB}]`] = val;
 				return val;
 			};
-			return safeObjectAssign$3(f, {
+			return safeObjectAssign$4(f, {
 				toString: () => {
 					const seenValues = safeObjectKeys$3(recorded).sort().map((k) => `${k} => ${stringify$2(recorded[k])}`).map((line) => `/* ${escapeForMultilineComments(line)} */`);
 					return `function(a, b) {
@@ -89267,7 +88270,7 @@ function buildCompareFunctionArbitrary(cmp) {
 		return producer();
 	});
 }
-var safeObjectAssign$2 = Object.assign;
+var safeObjectAssign$3 = Object.assign;
 /**
 * For comparison boolean functions
 *
@@ -89279,11 +88282,11 @@ var safeObjectAssign$2 = Object.assign;
 * @public
 */
 function compareBooleanFunc() {
-	return buildCompareFunctionArbitrary(safeObjectAssign$2((hA, hB) => hA < hB, { toString() {
+	return buildCompareFunctionArbitrary(safeObjectAssign$3((hA, hB) => hA < hB, { toString() {
 		return "(hA, hB) => hA < hB";
 	} }));
 }
-var safeObjectAssign$1 = Object.assign;
+var safeObjectAssign$2 = Object.assign;
 /**
 * For comparison functions
 *
@@ -89300,7 +88303,7 @@ var safeObjectAssign$1 = Object.assign;
 * @public
 */
 function compareFunc() {
-	return buildCompareFunctionArbitrary(safeObjectAssign$1((hA, hB) => hA - hB, { toString() {
+	return buildCompareFunctionArbitrary(safeObjectAssign$2((hA, hB) => hA - hB, { toString() {
 		return "(hA, hB) => hA - hB";
 	} }));
 }
@@ -89666,7 +88669,7 @@ function initialPoolForEntityGraph(keys, constraints) {
 	if (!canHaveAtLeastOneItem(keys, constraints)) throw new SError("Contraints on pool must accept at least one entity, maxLength cannot sum to 0");
 	return tuple(...keys.map((key) => array(constant(key), constraints[key]))).map((values) => safeFlat(values)).filter((names) => names.length > 0);
 }
-var safeObjectAssign = Object.assign;
+var safeObjectAssign$1 = Object.assign;
 var safeObjectCreate$4 = Object.create;
 var safeObjectDefineProperty$1 = Object.defineProperty;
 var safeObjectGetPrototypeOf = Object.getPrototypeOf;
@@ -89691,7 +88694,7 @@ function unlinkedToLinkedEntitiesMapper(unlinkedEntities, producedLinks) {
 		const unlinkedEntitiesForName = unlinkedEntities[name];
 		const linkedEntitiesForName = [];
 		for (const unlinkedEntity of unlinkedEntitiesForName) {
-			const linkedEntity = safeObjectAssign(safeObjectCreate$4(safeObjectGetPrototypeOf(unlinkedEntity)), unlinkedEntity);
+			const linkedEntity = safeObjectAssign$1(safeObjectCreate$4(safeObjectGetPrototypeOf(unlinkedEntity)), unlinkedEntity);
 			linkedEntitiesForName.push(linkedEntity);
 		}
 		linkedEntities[name] = linkedEntitiesForName;
@@ -89711,7 +88714,7 @@ function unlinkedToLinkedEntitiesMapper(unlinkedEntities, producedLinks) {
 				writable: false,
 				value: () => {
 					const unlinkedEntity = unlinkedEntities[name][entityIndex];
-					const entity = safeObjectAssign(safeObjectCreate$4(safeObjectGetPrototypeOf(unlinkedEntity)), unlinkedEntity);
+					const entity = safeObjectAssign$1(safeObjectCreate$4(safeObjectGetPrototypeOf(unlinkedEntity)), unlinkedEntity);
 					for (const prop in entityLinksForInstance) {
 						const propValue = entityLinksForInstance[prop];
 						entity[prop] = propValue.index === void 0 ? void 0 : typeof propValue.index === "number" ? withReferenceStringifiedValue(propValue.type, propValue.index) : safeMap(propValue.index, (index) => withReferenceStringifiedValue(propValue.type, index));
@@ -89766,6 +88769,7 @@ function buildInversedRelationsMapping(relations) {
 	if (inversedRelations.size !== foundInversedRelations) throw new SError(`Some inverse relationships could not be matched with their corresponding forward relationships`);
 	return inversedRelations;
 }
+var safeObjectAssign = Object.assign;
 var safeObjectCreate$3 = Object.create;
 /** @internal */
 function produceLinkUnitaryIndexArbitrary(strategy, currentIndexIfSameType, countInTargetType) {
@@ -89782,128 +88786,200 @@ function produceLinkUnitaryIndexArbitrary(strategy, currentIndexIfSameType, coun
 	}
 }
 /** @internal */
-function computeLinkIndex(arity, strategy, currentIndexIfSameType, countInTargetType, currentEntityDepth, mrng, biasFactor) {
+function buildLinkIndexArbitrary(arity, strategy, currentIndexIfSameType, countInTargetType, currentEntityDepth) {
 	const linkArbitrary = produceLinkUnitaryIndexArbitrary(strategy, currentIndexIfSameType, countInTargetType);
 	switch (arity) {
 		case "0-1": return option$3(linkArbitrary, {
 			nil: void 0,
 			depthIdentifier: currentEntityDepth
-		}).generate(mrng, biasFactor).value;
-		case "1": return linkArbitrary.generate(mrng, biasFactor).value;
+		});
+		case "1": return linkArbitrary;
 		case "many": {
 			let randomUnicity = 0;
-			const values = option$3(uniqueArray(linkArbitrary, {
+			return option$3(uniqueArray(linkArbitrary, {
 				depthIdentifier: currentEntityDepth,
 				selector: (v) => v === countInTargetType ? v + ++randomUnicity : v,
 				minLength: 1
 			}), {
 				nil: [],
 				depthIdentifier: currentEntityDepth
-			}).generate(mrng, biasFactor).value;
-			let offset = 0;
-			return safeMap(values, (v) => v === countInTargetType ? v + offset++ : v);
+			}).map((values) => {
+				let offset = 0;
+				return safeMap(values, (v) => v === countInTargetType ? v + offset++ : v);
+			});
 		}
 	}
 }
 /** @internal */
-var OnTheFlyLinksForEntityGraphArbitrary = class extends Arbitrary {
-	constructor(relations, defaultEntities) {
-		super();
-		this.relations = relations;
-		this.defaultEntities = defaultEntities;
-		const nonExclusiveEntities = new SSet();
-		const exclusiveEntities = new SSet();
-		for (const name in relations) {
-			const relationsForName = relations[name];
-			for (const fieldName in relationsForName) {
-				const relation = relationsForName[fieldName];
-				if (relation.arity === "inverse") continue;
-				if (relation.strategy === "exclusive") {
-					if (safeHas(nonExclusiveEntities, relation.type)) throw new SError(`Cannot mix exclusive with other strategies for type ${SString(relation.type)}`);
-					safeAdd(exclusiveEntities, relation.type);
-				} else {
-					if (safeHas(exclusiveEntities, relation.type)) throw new SError(`Cannot mix exclusive with other strategies for type ${SString(relation.type)}`);
-					safeAdd(nonExclusiveEntities, relation.type);
-				}
-				if (relation.strategy === "successor" && relation.type !== name) throw new SError(`Cannot mix types for the strategy successor`);
-				if (relation.strategy === "successor" && relation.arity === "1") throw new SError(`Cannot use an arity of 1 for the strategy successor`);
+function createEmptyLinksInstanceFor(relations, targetType) {
+	const emptyLinksInstance = safeObjectCreate$3(null);
+	const relationsForType = relations[targetType];
+	for (const name in relationsForType) {
+		const relation = relationsForType[name];
+		if (relation.arity === "inverse") emptyLinksInstance[name] = {
+			type: relation.type,
+			index: []
+		};
+	}
+	return emptyLinksInstance;
+}
+/** @internal */
+function assertAcceptableRelations(relations) {
+	const nonExclusiveEntities = new SSet();
+	const exclusiveEntities = new SSet();
+	for (const name in relations) {
+		const relationsForName = relations[name];
+		for (const fieldName in relationsForName) {
+			const relation = relationsForName[fieldName];
+			if (relation.arity === "inverse") continue;
+			if (relation.strategy === "exclusive") {
+				if (safeHas(nonExclusiveEntities, relation.type)) throw new SError(`Cannot mix exclusive with other strategies for type ${SString(relation.type)}`);
+				safeAdd(exclusiveEntities, relation.type);
+			} else {
+				if (safeHas(exclusiveEntities, relation.type)) throw new SError(`Cannot mix exclusive with other strategies for type ${SString(relation.type)}`);
+				safeAdd(nonExclusiveEntities, relation.type);
 			}
+			if (relation.strategy === "successor" && relation.type !== name) throw new SError(`Cannot mix types for the strategy successor`);
+			if (relation.strategy === "successor" && relation.arity === "1") throw new SError(`Cannot use an arity of 1 for the strategy successor`);
 		}
-		this.inversedRelations = buildInversedRelationsMapping(relations);
 	}
-	createEmptyLinksInstanceFor(targetType) {
-		const emptyLinksInstance = safeObjectCreate$3(null);
-		const relationsForType = this.relations[targetType];
-		for (const name in relationsForType) {
-			const relation = relationsForType[name];
-			if (relation.arity === "inverse") emptyLinksInstance[name] = {
-				type: relation.type,
-				index: []
+}
+/** @internal */
+function draftNextProductionState(state, offset) {
+	const { producedLinks, toBeProducedEntities } = state;
+	const nextIndex = state.nextIndex + offset;
+	const newProducedLinks = safeObjectAssign(safeObjectCreate$3(null), producedLinks);
+	function getOrCreateProducedLinksFor(type) {
+		if (newProducedLinks[type] === producedLinks[type]) newProducedLinks[type] = safeSlice(producedLinks[type]);
+		return newProducedLinks[type];
+	}
+	function getOrCreateLinksFor(type, indexInType) {
+		const producedLinksForType = getOrCreateProducedLinksFor(type);
+		if (producedLinksForType[indexInType] === producedLinks[type][indexInType]) producedLinksForType[indexInType] = safeObjectAssign(safeObjectCreate$3(null), producedLinks[type][indexInType]);
+		return producedLinksForType[indexInType];
+	}
+	function getOrCreateRelationFor(type, indexInType, property) {
+		const links = getOrCreateLinksFor(type, indexInType);
+		const originalEntity = producedLinks[type][indexInType];
+		if (originalEntity !== void 0 && links[property] === originalEntity[property]) {
+			const sharedRelation = links[property];
+			links[property] = {
+				type: sharedRelation.type,
+				index: typeof sharedRelation.index === "object" ? safeSlice(sharedRelation.index) : sharedRelation.index
 			};
 		}
-		return emptyLinksInstance;
+		return links[property];
 	}
-	generate(mrng, biasFactor) {
-		const producedLinks = safeObjectCreate$3(null);
-		for (const name in this.relations) producedLinks[name] = [];
-		const toBeProducedEntities = [];
-		for (const name of this.defaultEntities) {
-			safePush(toBeProducedEntities, {
-				type: name,
-				indexInType: producedLinks[name].length,
-				depth: 0
+	let newToBeProducedEntities = void 0;
+	const toBeProduced = toBeProducedEntities[nextIndex];
+	return {
+		setOutboundLink: (name, value) => {
+			const currentLinks = getOrCreateLinksFor(toBeProduced.type, toBeProduced.indexInType);
+			currentLinks[name] = value;
+		},
+		enqueueNewEntity: (relations, targetType) => {
+			const producedLinksInTargetType = getOrCreateProducedLinksFor(targetType);
+			const newEntityIndexInType = producedLinksInTargetType.length;
+			if (newToBeProducedEntities === void 0) newToBeProducedEntities = safeSlice(toBeProducedEntities);
+			safePush(newToBeProducedEntities, {
+				type: targetType,
+				indexInType: newEntityIndexInType,
+				depth: toBeProduced.depth + 1
 			});
-			safePush(producedLinks[name], this.createEmptyLinksInstanceFor(name));
-		}
-		let lastTreatedEntities = -1;
-		while (++lastTreatedEntities < toBeProducedEntities.length) {
-			const currentEntity = toBeProducedEntities[lastTreatedEntities];
-			const currentRelations = this.relations[currentEntity.type];
-			const currentLinks = producedLinks[currentEntity.type][currentEntity.indexInType];
-			const currentEntityDepth = createDepthIdentifier();
-			currentEntityDepth.depth = currentEntity.depth;
-			for (const name in currentRelations) {
-				const relation = currentRelations[name];
-				if (relation.arity === "inverse") continue;
-				const targetType = relation.type;
-				const producedLinksInTargetType = producedLinks[targetType];
-				const countInTargetType = producedLinksInTargetType.length;
-				const linkOrLinks = computeLinkIndex(relation.arity, relation.strategy || "any", targetType === currentEntity.type ? currentEntity.indexInType : void 0, producedLinksInTargetType.length, currentEntityDepth, mrng, biasFactor);
-				currentLinks[name] = {
-					type: targetType,
-					index: linkOrLinks
-				};
-				const links = linkOrLinks === void 0 ? [] : typeof linkOrLinks === "number" ? [linkOrLinks] : linkOrLinks;
-				for (const link of links) {
-					if (link >= countInTargetType) {
-						safePush(toBeProducedEntities, {
-							type: targetType,
-							indexInType: link,
-							depth: currentEntity.depth + 1
-						});
-						safePush(producedLinksInTargetType, this.createEmptyLinksInstanceFor(targetType));
-					}
-					const inversed = safeMapGet(this.inversedRelations, relation);
-					if (inversed !== void 0) {
-						const knownInversedLinks = producedLinksInTargetType[link][inversed.property].index;
-						safePush(knownInversedLinks, currentEntity.indexInType);
-					}
-				}
-			}
-		}
-		toBeProducedEntities.length = 0;
-		return new Value(producedLinks, void 0);
-	}
-	canShrinkWithoutContext(_value) {
-		return false;
+			safePush(producedLinksInTargetType, createEmptyLinksInstanceFor(relations, targetType));
+			return newEntityIndexInType;
+		},
+		appendBackReference: (targetType, indexInType, property) => {
+			const knownInversedLinks = getOrCreateRelationFor(targetType, indexInType, property).index;
+			safePush(knownInversedLinks, toBeProduced.indexInType);
+		},
+		commit: () => ({
+			producedLinks: newProducedLinks,
+			toBeProducedEntities: newToBeProducedEntities !== void 0 ? newToBeProducedEntities : toBeProducedEntities,
+			nextIndex: nextIndex + 1
+		})
+	};
+}
+/** @internal */
+function buildInitialProductionState(relations, defaultEntities) {
+	const producedLinks = safeObjectCreate$3(null);
+	for (const name in relations) producedLinks[name] = [];
+	const toBeProducedEntities = [];
+	for (const name of defaultEntities) {
+		safePush(toBeProducedEntities, {
+			type: name,
+			indexInType: producedLinks[name].length,
+			depth: 0
+		});
+		safePush(producedLinks[name], createEmptyLinksInstanceFor(relations, name));
 	}
-	shrink(_value, _context) {
-		return Stream.nil();
+	return {
+		producedLinks,
+		toBeProducedEntities,
+		nextIndex: 0
+	};
+}
+/** @internal */
+function buildEntityStepArbitrary(relations, inversedRelations, lastState, offset) {
+	const lastProducedLinks = lastState.producedLinks;
+	const currentEntity = lastState.toBeProducedEntities[lastState.nextIndex + offset];
+	const currentRelations = relations[currentEntity.type];
+	const currentEntityDepth = createDepthIdentifier();
+	currentEntityDepth.depth = currentEntity.depth;
+	const subArbitraries = [];
+	const linkContexts = [];
+	for (const name in currentRelations) {
+		const relation = currentRelations[name];
+		if (relation.arity === "inverse") continue;
+		const targetType = relation.type;
+		const countInTargetType = lastProducedLinks[targetType].length;
+		safePush(subArbitraries, buildLinkIndexArbitrary(relation.arity, relation.strategy || "any", targetType === currentEntity.type ? currentEntity.indexInType : void 0, countInTargetType, currentEntityDepth));
+		safePush(linkContexts, {
+			name,
+			relation,
+			sentinelLinkIndex: countInTargetType
+		});
 	}
-};
+	if (subArbitraries.length === 0) return;
+	return tuple(...subArbitraries).map((results) => {
+		const state = draftNextProductionState(lastState, offset);
+		for (let resultIndex = 0; resultIndex !== results.length; ++resultIndex) {
+			const linkOrLinks = results[resultIndex];
+			const { name, relation, sentinelLinkIndex } = linkContexts[resultIndex];
+			const effectiveLinks = [];
+			const links = linkOrLinks === void 0 ? [] : typeof linkOrLinks === "number" ? [linkOrLinks] : linkOrLinks;
+			for (const link of links) {
+				let newEntityIndexInType;
+				if (link >= sentinelLinkIndex) newEntityIndexInType = state.enqueueNewEntity(relations, relation.type);
+				else newEntityIndexInType = link;
+				safePush(effectiveLinks, newEntityIndexInType);
+				const inversed = safeMapGet(inversedRelations, relation);
+				if (inversed !== void 0) state.appendBackReference(relation.type, newEntityIndexInType, inversed.property);
+			}
+			state.setOutboundLink(name, {
+				type: relation.type,
+				index: linkOrLinks === void 0 ? void 0 : typeof linkOrLinks === "number" ? effectiveLinks[0] : effectiveLinks
+			});
+		}
+		return state.commit();
+	});
+}
 /** @internal */
 function onTheFlyLinksForEntityGraph(relations, defaultEntities) {
-	return new OnTheFlyLinksForEntityGraphArbitrary(relations, defaultEntities);
+	assertAcceptableRelations(relations);
+	const inversedRelations = buildInversedRelationsMapping(relations);
+	return chainUntil(constant(buildInitialProductionState(relations, defaultEntities)), (state) => {
+		if (state.nextIndex >= state.toBeProducedEntities.length) return;
+		let offset = 0;
+		let next = void 0;
+		while (next === void 0 && state.nextIndex + offset < state.toBeProducedEntities.length) {
+			next = buildEntityStepArbitrary(relations, inversedRelations, state, offset);
+			offset += 1;
+		}
+		return next;
+	}).map((state) => {
+		return state.producedLinks;
+	});
 }
 var safeObjectKeys$1 = Object.keys;
 var safeObjectGetOwnPropertySymbols$1 = Object.getOwnPropertySymbols;
@@ -89927,15 +89003,19 @@ var safeObjectGetOwnPropertySymbols = Object.getOwnPropertySymbols;
 /** @internal */
 function buildValuesAndSeparateKeysToObjectMapper(keys, noKeyValue) {
 	return function valuesAndSeparateKeysToObjectMapper(definition) {
-		const obj = definition[1] ? safeObjectCreate$2(null) : {};
+		const obj = definition[definition.length - 1] ? safeObjectCreate$2(null) : {};
 		for (let idx = 0; idx !== keys.length; ++idx) {
-			const valueWrapper = definition[0][idx];
-			if (valueWrapper !== noKeyValue) safeObjectDefineProperty(obj, keys[idx], {
-				value: valueWrapper,
-				configurable: true,
-				enumerable: true,
-				writable: true
-			});
+			const valueWrapper = definition[idx];
+			if (valueWrapper !== noKeyValue) {
+				const key = keys[idx];
+				if (key === "__proto__") safeObjectDefineProperty(obj, key, {
+					value: valueWrapper,
+					configurable: true,
+					enumerable: true,
+					writable: true
+				});
+				else obj[key] = valueWrapper;
+			}
 		}
 		return obj;
 	};
@@ -89961,7 +89041,7 @@ function buildValuesAndSeparateKeysToObjectUnmapper(keys, noKeyValue) {
 		const namePropertiesCount = safeObjectGetOwnPropertyNames(value).length;
 		const symbolPropertiesCount = safeObjectGetOwnPropertySymbols(value).length;
 		if (extractedPropertiesCount !== namePropertiesCount + symbolPropertiesCount) throw new Error("Incompatible instance received: should not contain extra properties");
-		return [extractedValues, hasNullPrototype];
+		return [...extractedValues, hasNullPrototype];
 	};
 }
 var noKeyValue = Symbol("no-key");
@@ -89975,7 +89055,7 @@ function buildPartialRecordArbitrary(recordModel, requiredKeys, noNullPrototype)
 		if (requiredKeys === void 0 || safeIndexOf(requiredKeys, k) !== -1) safePush(arbs, requiredArbitrary);
 		else safePush(arbs, option$3(requiredArbitrary, { nil: noKeyValue }));
 	}
-	return tuple(tuple(...arbs), noNullPrototype ? constant(false) : boolean$3()).map(buildValuesAndSeparateKeysToObjectMapper(keys, noKeyValue), buildValuesAndSeparateKeysToObjectUnmapper(keys, noKeyValue));
+	return tuple(...arbs, noNullPrototype ? constant(false) : boolean$3()).map(buildValuesAndSeparateKeysToObjectMapper(keys, noKeyValue), buildValuesAndSeparateKeysToObjectUnmapper(keys, noKeyValue));
 }
 function record$1(recordModel, constraints) {
 	const noNullPrototype = constraints !== void 0 && !!constraints.noNullPrototype;
@@ -91388,7 +90468,9 @@ function webSegment(constraints = {}) {
 }
 /** @internal */
 function segmentsToPathMapper(segments) {
-	return safeJoin(safeMap(segments, (v) => `/${v}`), "");
+	let path = "";
+	for (let index = 0; index !== segments.length; ++index) path += "/" + segments[index];
+	return path;
 }
 /** @internal */
 function segmentsToPathUnmapper(value) {
@@ -93379,6 +92461,11 @@ var spaceChars = [..." 	\r\n\v\f"];
 var newLineChars = [..."\r\n"];
 var terminatorChars = [...""];
 var newLineAndTerminatorChars = [...newLineChars, ...terminatorChars];
+var wordCharsSet = new SSet(wordChars);
+var digitCharsSet = new SSet(digitChars);
+var spaceCharsSet = new SSet(spaceChars);
+var terminatorCharsSet = new SSet(terminatorChars);
+var newLineAndTerminatorCharsSet = new SSet(newLineAndTerminatorChars);
 var defaultChar = () => string$4({
 	unit: "grapheme-ascii",
 	minLength: 1,
@@ -93396,16 +92483,16 @@ function toMatchingArbitrary(astNode, constraints, flags) {
 		case "Char":
 			if (astNode.kind === "meta") switch (astNode.value) {
 				case "\\w": return constantFrom(...wordChars);
-				case "\\W": return defaultChar().filter((c) => safeIndexOf(wordChars, c) === -1);
+				case "\\W": return defaultChar().filter((c) => !safeHas(wordCharsSet, c));
 				case "\\d": return constantFrom(...digitChars);
-				case "\\D": return defaultChar().filter((c) => safeIndexOf(digitChars, c) === -1);
+				case "\\D": return defaultChar().filter((c) => !safeHas(digitCharsSet, c));
 				case "\\s": return constantFrom(...spaceChars);
-				case "\\S": return defaultChar().filter((c) => safeIndexOf(spaceChars, c) === -1);
+				case "\\S": return defaultChar().filter((c) => !safeHas(spaceCharsSet, c));
 				case "\\b":
 				case "\\B": throw new SError(`Meta character ${astNode.value} not implemented yet!`);
 				case ".": {
-					const forbiddenChars = flags.dotAll ? terminatorChars : newLineAndTerminatorChars;
-					return defaultChar().filter((c) => safeIndexOf(forbiddenChars, c) === -1);
+					const forbiddenChars = flags.dotAll ? terminatorCharsSet : newLineAndTerminatorCharsSet;
+					return defaultChar().filter((c) => !safeHas(forbiddenChars, c));
 				}
 			}
 			if (astNode.symbol === void 0) throw new SError(`Unexpected undefined symbol received for non-meta Char! Received: ${stringify$2(astNode)}`);
@@ -93438,7 +92525,22 @@ function toMatchingArbitrary(astNode, constraints, flags) {
 			}
 		}
 		case "Quantifier": throw new SError(`Wrongly defined AST tree, Quantifier nodes not supposed to be scanned!`);
-		case "Alternative": return tuple(...safeMap(astNode.expressions, (n) => toMatchingArbitrary(n, constraints, flags))).map((vs) => safeJoin(vs, ""));
+		case "Alternative": {
+			const childrenArbitraries = [];
+			let pendingAggregatedValue = "";
+			for (const n of astNode.expressions) if (n.type === "Char" && n.kind !== "meta" && n.symbol !== void 0) pendingAggregatedValue += n.symbol;
+			else if (flags.multiline || n.type !== "Assertion" || n.kind !== "^" && n.kind !== "$") {
+				if (pendingAggregatedValue !== "") {
+					safePush(childrenArbitraries, constant(pendingAggregatedValue));
+					pendingAggregatedValue = "";
+				}
+				safePush(childrenArbitraries, toMatchingArbitrary(n, constraints, flags));
+			}
+			if (pendingAggregatedValue !== "") safePush(childrenArbitraries, constant(pendingAggregatedValue));
+			if (childrenArbitraries.length === 0) return constant("");
+			if (childrenArbitraries.length === 1) return childrenArbitraries[0];
+			return tuple(...childrenArbitraries).map((vs) => safeJoin(vs, ""));
+		}
 		case "CharacterClass":
 			if (astNode.negative) {
 				const childrenArbitraries = safeMap(astNode.expressions, (n) => toMatchingArbitrary(n, constraints, flags));
@@ -93458,7 +92560,19 @@ function toMatchingArbitrary(astNode, constraints, flags) {
 			});
 		}
 		case "Group": return toMatchingArbitrary(astNode.expression, constraints, flags);
-		case "Disjunction": return oneof(astNode.left !== null ? toMatchingArbitrary(astNode.left, constraints, flags) : constant(""), astNode.right !== null ? toMatchingArbitrary(astNode.right, constraints, flags) : constant(""));
+		case "Disjunction": {
+			const stack = [astNode.left, astNode.right];
+			const branches = [];
+			for (let i = 0; i !== stack.length; ++i) {
+				const node = stack[i];
+				if (node === null) safePush(branches, constant(""));
+				else if (node.type === "Disjunction") {
+					safePush(stack, node.left);
+					safePush(stack, node.right);
+				} else safePush(branches, toMatchingArbitrary(node, constraints, flags));
+			}
+			return oneof(...branches);
+		}
 		case "Assertion":
 			if (astNode.kind === "^" || astNode.kind === "$") {
 				if (flags.multiline) if (astNode.kind === "^") return oneof(constant(""), tuple(string$4({ unit: defaultChar() }), constantFrom(...newLineChars)).map((t) => `${t[0]}${t[1]}`, (value) => {
@@ -93598,17 +92712,17 @@ function limitShrink(arbitrary, maxShrinks) {
 */
 var __type = "module";
 /**
-* Version of fast-check used by your project (eg.: "4.8.0")
+* Version of fast-check used by your project (eg.: "4.9.0")
 * @remarks Since 1.22.0
 * @public
 */
-var __version = "4.8.0";
+var __version = "4.9.0";
 /**
-* Commit hash of the current code (eg.: "c0da76fbcf6470339ad7bb2f0dfcebee06ede56c")
+* Commit hash of the current code (eg.: "0d3c2547dce556f72413607849377530d18ea283")
 * @remarks Since 2.7.0
 * @public
 */
-var __commitHash = "c0da76fbcf6470339ad7bb2f0dfcebee06ede56c";
+var __commitHash = "0d3c2547dce556f72413607849377530d18ea283";
 //#endregion
 //#region ../../node_modules/effect/dist/testing/FastCheck.js
 var FastCheck_exports = /* @__PURE__ */ __exportAll({
@@ -93757,6 +92871,7 @@ var Schema_exports = /* @__PURE__ */ __exportAll({
 	Chunk: () => Chunk,
 	Class: () => Class,
 	Date: () => Date$1,
+	DateFromMillis: () => DateFromMillis,
 	DateFromString: () => DateFromString,
 	DateTimeUtc: () => DateTimeUtc,
 	DateTimeUtcFromDate: () => DateTimeUtcFromDate,
@@ -99647,6 +98762,8 @@ var DateString = /*#__PURE__*/ String$1.annotate({ expected: "a string in ISO 86
 * ```
 *
 * @see {@link DateValid} for accepting only valid Date instances
+* @see {@link DateFromString} for decoding strings into Date instances
+* @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
 *
 * @category Date
 * @since 4.0.0
@@ -99682,6 +98799,8 @@ var Date$1 = /*#__PURE__*/ instanceOf$2(globalThis.Date, {
 *
 * Invalid date strings can decode to invalid `Date` instances.
 *
+* @see {@link DateFromMillis} for decoding epoch milliseconds into Date instances
+* @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
 * @see {@link Date} for accepting Date instances directly
 * @see {@link DateValid} for rejecting invalid Date instances
 *
@@ -99690,6 +98809,34 @@ var Date$1 = /*#__PURE__*/ instanceOf$2(globalThis.Date, {
 */
 var DateFromString = /*#__PURE__*/ DateString.pipe(/*#__PURE__*/ decodeTo(Date$1, dateFromString));
 /**
+* Schema that decodes epoch milliseconds into a JavaScript `Date`.
+*
+* **When to use**
+*
+* Use to model numeric millisecond timestamps that decode to JavaScript `Date`
+* objects and encode back to numbers.
+*
+* **Details**
+*
+* Decoding:
+* A number of milliseconds since the Unix epoch is decoded as a `Date`.
+*
+* Encoding:
+* A `Date` is encoded as its millisecond timestamp.
+*
+* **Gotchas**
+*
+* This schema accepts any number, including `NaN`, `Infinity`, and `-Infinity`.
+* Those values decode to invalid `Date` instances.
+*
+* @see {@link DateFromString} for decoding string-encoded dates
+* @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
+*
+* @category Date
+* @since 4.0.0
+*/
+var DateFromMillis = /*#__PURE__*/ Number$1.pipe(/*#__PURE__*/ decodeTo(Date$1, dateFromMillis));
+/**
 * Schema for **valid** JavaScript `Date` objects.
 *
 * **Details**
@@ -100701,6 +99848,10 @@ var DateTimeUtcFromDate = /*#__PURE__*/ DateValid.pipe(/*#__PURE__*/ decodeTo(Da
 *
 * - A `DateTime.Utc` is encoded as a UTC ISO 8601 string.
 *
+* @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values
+* @see {@link DateTimeUtcFromMillis} for decoding epoch milliseconds into UTC values
+* @see {@link DateFromString} for decoding strings into JavaScript Date instances
+*
 * @category DateTime
 * @since 4.0.0
 */
@@ -100716,6 +99867,10 @@ var DateTimeUtcFromString = /*#__PURE__*/ String$1.annotate({ expected: "a strin
 * Encoding:
 * - A `DateTime.Utc` is encoded as a number of milliseconds since the Unix epoch.
 *
+* @see {@link DateTimeUtcFromDate} for decoding JavaScript Date values into UTC values
+* @see {@link DateTimeUtcFromString} for decoding date-time strings into UTC values
+* @see {@link DateFromMillis} for decoding epoch milliseconds into JavaScript Date instances
+*
 * @category DateTime
 * @since 4.0.0
 */
@@ -105362,7 +104517,7 @@ var fromAsyncIterable = (iterable, onError) => fromChannel(fromAsyncIterableArra
 *
 * const program = Effect.gen(function*() {
 *   const schedule = Schedule.spaced("50 millis").pipe(
-*     Schedule.both(Schedule.recurs(2))
+*     Schedule.upTo({ times: 3 })
 *   )
 *   const stream = Stream.fromSchedule(schedule)
 *   const values = yield* Stream.runCollect(stream)
@@ -112378,6 +111533,9 @@ var makeNoop = (fileSystem) => FileSystem.of({
 	copyFile(path) {
 		return fail$8(notFound("copyFile", path));
 	},
+	glob(pattern) {
+		return fail$8(notFound("glob", pattern));
+	},
 	exists() {
 		return succeed$6(false);
 	},
@@ -113595,6 +112753,16 @@ var layerAdd = (self, options) => effect(ConfigProvider)(gen$1(function* () {
 * Primitive values (`number`, `boolean`, `bigint`) are stringified via
 * `String(...)`.
 *
+* Literal empty strings are treated as missing values when loaded as values by
+* default. Pass `{ preserveEmptyStrings: true }` to keep empty strings as
+* explicit values.
+*
+* **Gotchas**
+*
+* Object keys and array lengths reflect the original input shape. A leaf value
+* of `""` is treated as missing when that leaf is loaded, but the parent
+* container still reports its original keys or length.
+*
 * **Example** (Providing config from a plain object)
 *
 * ```ts
@@ -113620,10 +112788,11 @@ var layerAdd = (self, options) => effect(ConfigProvider)(gen$1(function* () {
 * @category ConfigProviders
 * @since 4.0.0
 */
-function fromUnknown(root) {
-	return make$32((path) => succeed$6(nodeAtJson(root, path)));
+function fromUnknown(root, options) {
+	const preserveEmptyStrings = options?.preserveEmptyStrings === true;
+	return make$32((path) => succeed$6(nodeAtJson(root, path, preserveEmptyStrings)));
 }
-function nodeAtJson(root, path) {
+function nodeAtJson(root, path, preserveEmptyStrings) {
 	let cur = root;
 	for (const seg of path) {
 		if (cur === null || cur === void 0) return void 0;
@@ -113640,16 +112809,23 @@ function nodeAtJson(root, path) {
 		}
 		return;
 	}
-	return describeUnknown(cur);
+	return describeUnknown(cur, preserveEmptyStrings);
 }
-function describeUnknown(u) {
+function describeUnknown(u, preserveEmptyStrings) {
 	if (u === void 0 || u === null) return void 0;
-	if (typeof u === "string") return makeValue(u);
+	if (typeof u === "string") return stringNode(u, preserveEmptyStrings);
 	if (typeof u === "number" || typeof u === "boolean" || typeof u === "bigint") return makeValue(String(u));
 	if (Array.isArray(u)) return makeArray(u.length);
 	if (isObject(u)) return makeRecord(new Set(Object.keys(u)));
 	return makeValue(format$5(u));
 }
+function stringNode(value, preserveEmptyStrings) {
+	const normalized = emptyStringAsMissing(value, preserveEmptyStrings);
+	return normalized === void 0 ? void 0 : makeValue(normalized);
+}
+function emptyStringAsMissing(value, preserveEmptyStrings) {
+	return value === "" && !preserveEmptyStrings ? void 0 : value;
+}
 /**
 * Creates a `ConfigProvider` backed by environment variables.
 *
@@ -113671,6 +112847,11 @@ function describeUnknown(u) {
 * The default environment merges `process.env` and `import.meta.env` (when
 * available). Override by passing `{ env: { ... } }`.
 *
+* Literal empty strings are treated as missing values when loaded as values by
+* default. Pass `{ preserveEmptyStrings: true }` to keep empty strings as
+* explicit values. Child discovery still reflects the environment variable
+* names present in the source.
+*
 * Never fails with `SourceError` — all lookups are synchronous.
 *
 * **Example** (Reading from a custom env record)
@@ -113707,26 +112888,26 @@ function fromEnv(options) {
 		"PROD": true,
 		"SSR": false
 	};
+	const preserveEmptyStrings = options?.preserveEmptyStrings === true;
 	const trie = buildEnvTrie(env);
-	return make$32((path) => succeed$6(nodeAtEnv(trie, env, path)));
+	return make$32((path) => succeed$6(nodeAtEnv(trie, env, path, preserveEmptyStrings)));
 }
 function buildEnvTrie(env) {
-	const root = {};
+	const trie = {};
 	for (const [name, value] of Object.entries(env)) {
 		if (value === void 0) continue;
 		const segments = name.split("_");
-		let node = root;
+		let node = trie;
 		for (const seg of segments) {
 			node.children ??= {};
 			node = node.children[seg] ??= {};
 		}
-		node.value = value;
 	}
-	return root;
+	return trie;
 }
 var NUMERIC_INDEX = /^(0|[1-9][0-9]*)$/;
-function nodeAtEnv(trie, env, path) {
-	const leafValue = env[path.map(String).join("_")];
+function nodeAtEnv(trie, env, path, preserveEmptyStrings) {
+	const leafValue = emptyStringAsMissing(env[path.map(String).join("_")], preserveEmptyStrings);
 	const trieNode = trieNodeAt(trie, path);
 	const children = trieNode?.children ? Object.keys(trieNode.children) : [];
 	if (children.length === 0) return leafValue === void 0 ? void 0 : makeValue(leafValue);
@@ -113756,6 +112937,11 @@ function trieNodeAt(root, path) {
 * and escaped newlines. Variable expansion (for example, `${VAR}`) is disabled
 * by default; enable with `{ expandVariables: true }`.
 *
+* Literal empty strings are treated as missing values when loaded as values by
+* default. Pass `{ preserveEmptyStrings: true }` to keep empty strings as
+* explicit values. Child discovery still reflects the keys present in the
+* parsed `.env` source.
+*
 * Parsing is based on the `dotenv` / `dotenv-expand` algorithm.
 *
 * Internally delegates to {@link fromEnv} with the parsed key-value pairs.
@@ -113783,7 +112969,10 @@ function trieNodeAt(root, path) {
 function fromDotEnvContents(lines, options) {
 	let env = parseDotEnvContents(lines);
 	if (options?.expandVariables) env = dotEnvExpand(env);
-	return fromEnv({ env });
+	return fromEnv({
+		env,
+		preserveEmptyStrings: options?.preserveEmptyStrings
+	});
 }
 var DOT_ENV_LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
 function parseDotEnvContents(lines) {
@@ -113835,6 +113024,13 @@ function searchLast(str, rgx) {
 *
 * Requires `FileSystem` in the Effect context. Defaults to reading `".env"` in
 * the current directory; override with `{ path: "/custom/.env" }`.
+* Variable expansion (for example, `${VAR}`) is disabled by default; enable
+* with `{ expandVariables: true }`.
+*
+* Literal empty strings are treated as missing values when loaded as values by
+* default. Pass `{ preserveEmptyStrings: true }` to keep empty strings as
+* explicit values. Child discovery still reflects the keys present in the
+* parsed `.env` source.
 *
 * Returns an `Effect` that resolves to a `ConfigProvider`. Fails with a
 * `PlatformError` if the file cannot be read.
@@ -113853,11 +113049,11 @@ function searchLast(str, rgx) {
 * @see {@link fromDotEnvContents} – parse a `.env` string directly
 * @see {@link fromEnv} – read from the runtime environment
 *
-* @category constructors
+* @category ConfigProviders
 * @since 4.0.0
 */
 var fromDotEnv = /*#__PURE__*/ fnUntraced(function* (options) {
-	return fromEnv({ env: parseDotEnvContents(yield* (yield* FileSystem).readFileString(options?.path ?? ".env")) });
+	return fromDotEnvContents(yield* (yield* FileSystem).readFileString(options?.path ?? ".env"), options);
 });
 /**
 * Creates a `ConfigProvider` that reads configuration from a directory tree
@@ -113870,15 +113066,20 @@ var fromDotEnv = /*#__PURE__*/ fnUntraced(function* (options) {
 *
 * **Details**
 *
-* Resolution tries a regular file first and returns a `Value` node with
-* trimmed file contents. If the file read fails, it tries a directory and
-* returns a `Record` node with immediate child names as keys. If both fail with
-* `NotFound`, it returns `undefined`. Other platform failures return
+* Resolution tries a regular file first and returns a `Value` node for
+* non-empty trimmed file contents. If the file read fails, it tries a directory
+* and returns a `Record` node with immediate child names as keys. If both fail
+* with `NotFound`, it returns `undefined`. Other platform failures return
 * `SourceError`.
 *
 * Requires `Path` and `FileSystem` in the Effect context. Defaults to root
 * path `/`; override with `{ rootPath: "/etc/config" }`.
 *
+* Literal empty strings are treated as missing values by default after file
+* contents are trimmed. Pass `{ preserveEmptyStrings: true }` to keep empty
+* strings as explicit values. Directory listings still reflect the file names
+* present on disk.
+*
 * **Example** (Reading config from a directory)
 *
 * ```ts
@@ -113902,9 +113103,10 @@ var fromDir = /*#__PURE__*/ fnUntraced(function* (options) {
 	const platformPath = yield* Path;
 	const fs = yield* FileSystem;
 	const rootPath = options?.rootPath ?? "/";
+	const preserveEmptyStrings = options?.preserveEmptyStrings === true;
 	return make$32((path) => {
 		const fullPath = platformPath.join(rootPath, ...path.map(String));
-		const asFile = fs.readFileString(fullPath).pipe(map$19((content) => makeValue(content.trim())));
+		const asFile = fs.readFileString(fullPath).pipe(map$19((content) => stringNode(content.trim(), preserveEmptyStrings)));
 		const asDirectory = fs.readDirectory(fullPath).pipe(map$19((entries) => makeRecord(new Set(entries.map((entry) => platformPath.basename(entry))))));
 		return asFile.pipe(catch_$3((fileCause) => asDirectory.pipe(catch_$3((dirCause) => isNotFound(fileCause) && isNotFound(dirCause) ? succeed$6(void 0) : fail$8(isNotFound(fileCause) ? dirCause : fileCause)))), mapError$3((cause) => new SourceError({
 			message: `Failed to read file at ${platformPath.join(rootPath, ...path.map(String))}`,
@@ -121645,7 +120847,7 @@ var TypeId$24 = "~effect/LayerMap";
 */
 var make$24 = /*#__PURE__*/ fnUntraced(function* (lookup, options) {
 	const context = yield* context$1();
-	const memoMap = CurrentMemoMap.getOrCreate(context);
+	const memoMap = CurrentMemoMap.forkOrCreate(context);
 	const rcMap = yield* make$37({
 		lookup: (key) => contextWith$1((_) => buildWithMemoMap(lookup(key), memoMap, get$27(_, Scope))),
 		idleTimeToLive: options?.idleTimeToLive
@@ -148955,7 +148157,7 @@ var LoomDocumentSchema = loomNode("LoomDocument", {
 });
 //#endregion
 //#region ../loom-lang/src/ast/LoomAstBuilder.ts
-var LoomAstBuilder = class extends Service$1()("LoomAstBuilder", { make: succeed$6({ build: (source) => runCollect(source).pipe(map$19((wefts) => makeDocument(reduce$11(groupNodes(wefts), initialDocument, appendToDocument)))) }) }) {
+var LoomAstBuilder = class extends Service$1()("LoomAstBuilder", { make: succeed$6({ build: (source) => runCollect(source).pipe(map$19((wefts) => makeDocument(reduce$10(groupNodes(wefts), initialDocument, appendToDocument)))) }) }) {
 	static {
 		this.layer = effect(this, this.make);
 	}
@@ -149170,7 +148372,7 @@ var buildProduct = (doc, modulePath, packageLanguage, variables = {}) => {
 	const pkg = pipe(fm, flatMapNullishOr$2((f) => f.package), map$29((p) => p.value));
 	const lang = pipe(frontmatterLanguage(fm), orElse$6(() => fromNullishOr$4(packageLanguage)), getOrElse$2(() => "plaintext"));
 	const index = nameIndex(doc.sections, lang, pkg);
-	return pipe(doc.sections, map$24(buildSection(index, lang, modulePath, pkg, variables)), reduce$11(emptyProduct, appendSection));
+	return pipe(doc.sections, map$24(buildSection(index, lang, modulePath, pkg, variables)), reduce$10(emptyProduct, appendSection));
 };
 var emptyProduct = ProductSchema.make({
 	code: [],
@@ -149199,7 +148401,7 @@ var nameIndex = (sections, defaultLang, pkg) => pipe(sections, map$24((s) => map
 	name: sectionNameOf(s),
 	pos: title.position,
 	language: sectionLanguage$1(s, defaultLang, pkg)
-}])), getSomes, reduce$11(/* @__PURE__ */ new Map(), (index, [title, entry]) => new Map(index).set(title, [...index.get(title) ?? [], entry])));
+}])), getSomes, reduce$10(/* @__PURE__ */ new Map(), (index, [title, entry]) => new Map(index).set(title, [...index.get(title) ?? [], entry])));
 var frontmatterLanguage = (frontmatter) => pipe(frontmatter, flatMapNullishOr$2((f) => f.language), map$29((l) => l.value.trim().toLowerCase()));
 var languageByExtension = /* @__PURE__ */ new Map([
 	["ts", "typescript"],
@@ -149503,11 +148705,11 @@ Struct({ modules: ReadonlyMap(String$1, Struct({
 	doc: LoomDocumentSchema,
 	product: ProductSchema
 })) });
-var resolveRelative = (from, rel) => pipe(rel.split("/"), filter$15((seg) => seg !== "" && seg !== "."), reduce$11(from.split("/").slice(0, -1), (acc, seg) => seg === ".." ? acc.slice(0, -1) : [...acc, seg]), join$6("/"));
+var resolveRelative = (from, rel) => pipe(rel.split("/"), filter$15((seg) => seg !== "" && seg !== "."), reduce$10(from.split("/").slice(0, -1), (acc, seg) => seg === ".." ? acc.slice(0, -1) : [...acc, seg]), join$6("/"));
 var titlesIn = (module) => pipe(module.doc.sections, map$24((section) => map$29(fromNullishOr$4(section.heading.title), (title) => [title.source, {
 	module: module.path,
 	section
-}])), getSomes, reduce$11(/* @__PURE__ */ new Map(), (index, [title, ref]) => index.has(title) ? index : new Map(index).set(title, ref)));
+}])), getSomes, reduce$10(/* @__PURE__ */ new Map(), (index, [title, ref]) => index.has(title) ? index : new Map(index).set(title, ref)));
 var titleIndexes = (modules) => new Map(fromIterable$15(modules.values()).map((m) => [m.path, titlesIn(m)]));
 var resolveAnchor = (indexes, from, anchor) => pipe(fromNullishOr$4(indexes.get(anchor.target === void 0 ? from : resolveRelative(from, anchor.target.value))), flatMap$13((index) => fromNullishOr$4(index.get(anchor.name.value))));
 var anchorsOf = (section) => pipe([...section.preamble, ...section.code], flatMap$10((weft) => weft.anchors));
@@ -149593,7 +148795,7 @@ var chapterTitleToken = (module) => orElse$6(fromNullishOr$4(module.doc.frontmat
 var chapterIndex = (modules) => pipe(fromIterable$15(modules.values()), map$24((module) => map$29(chapterTitleToken(module), (title) => [title.source, {
 	path: module.path,
 	position: title.position
-}])), getSomes, reduce$11(/* @__PURE__ */ new Map(), (index, [title, location]) => index.has(title) ? index : new Map(index).set(title, location)));
+}])), getSomes, reduce$10(/* @__PURE__ */ new Map(), (index, [title, location]) => index.has(title) ? index : new Map(index).set(title, location)));
 var tocEntriesOf = (module) => flatMap$10(module.doc.sections, (section) => section.entries ?? []);
 var tocEntryTitleAt = (modules, path, offset) => pipe(fromNullishOr$4(modules.get(path)), flatMap$13((module) => findFirst$6(tocEntriesOf(module), (entry) => entry.title !== void 0 && covers(entry.title.position, offset))), flatMap$13((entry) => fromNullishOr$4(entry.title)), map$29((title) => title.value));
 var frontmatterTitleAt = (modules, path, offset) => pipe(fromNullishOr$4(modules.get(path)), flatMap$13((module) => fromNullishOr$4(module.doc.frontmatter?.title)), filter$18((title) => covers(title.position, offset)), map$29((title) => title.value));
@@ -149623,7 +148825,7 @@ var partOpenerIndex = (modules) => pipe(fromIterable$15(modules.values()), map$2
 })), map$29(({ part, partName }) => [part.value, {
 	path: module.path,
 	position: partName.position
-}]))), getSomes, reduce$11(/* @__PURE__ */ new Map(), (index, [num, location]) => index.has(num) ? index : new Map(index).set(num, location)));
+}]))), getSomes, reduce$10(/* @__PURE__ */ new Map(), (index, [num, location]) => index.has(num) ? index : new Map(index).set(num, location)));
 var onToken = (token, offset) => match$13(fromNullishOr$4(token), {
 	onNone: () => false,
 	onSome: (t) => covers(t.position, offset)
@@ -149741,7 +148943,7 @@ var inlineComposed = (modules, seen) => (node) => {
 		vc: emptyLeaf,
 		trim: false
 	};
-	return pipe(node.fragments, reduce$11(seed, (acc, part, i) => {
+	return pipe(node.fragments, reduce$10(seed, (acc, part, i) => {
 		if (part.type === "Fragment") return {
 			vc: concat(acc.vc, build(acc.trim ? trimLeadingBlank(part) : part)),
 			trim: false
@@ -149841,7 +149043,7 @@ var fromProse = (modules, path) => match$13(fromNullishOr$4(modules.get(path)),
 		return {
 			id: "prose",
 			languageId: "prose",
-			code: pipe(module.doc.sections, flatMap$10((section) => section.code), filter$15(isCodeWeft), reduce$11(module.text, (acc, weft) => {
+			code: pipe(module.doc.sections, flatMap$10((section) => section.code), filter$15(isCodeWeft), reduce$10(module.text, (acc, weft) => {
 				const start = weft.position.start.offset;
 				const end = weft.position.end.offset;
 				return acc.slice(0, start) + acc.slice(start, end).replace(/[^\n]/g, " ") + acc.slice(end);
@@ -150184,10 +149386,10 @@ var romanUnits = {
 };
 var romanValue = (roman) => {
 	const units = map$24(roman.toUpperCase().split(""), (letter) => romanUnits[letter] ?? 0);
-	return pipe(units, map$24((unit, index) => unit < (units[index + 1] ?? 0) ? -unit : unit), reduce$11(0, (sum, unit) => sum + unit));
+	return pipe(units, map$24((unit, index) => unit < (units[index + 1] ?? 0) ? -unit : unit), reduce$10(0, (sum, unit) => sum + unit));
 };
 var identityOf = (part) => part.number === "" ? part.name : part.number;
-var dedupeParts = (decls) => reduce$11(decls, [], (kept, decl) => some$10(kept, (seen) => identityOf(seen) === identityOf(decl)) ? kept : [...kept, decl]);
+var dedupeParts = (decls) => reduce$10(decls, [], (kept, decl) => some$10(kept, (seen) => identityOf(seen) === identityOf(decl)) ? kept : [...kept, decl]);
 var byPart = combineAll([
 	mapInput$4(Number$5, (part) => part.number === "" ? 1 : 0),
 	mapInput$4(Number$5, (part) => part.number === "" ? 0 : romanValue(part.number)),
@@ -150221,7 +149423,7 @@ var flushed = (state) => {
 	});
 };
 var descriptionsFrom = (modules) => {
-	return flushed(reduce$11(bookEntries(modules), {
+	return flushed(reduce$10(bookEntries(modules), {
 		part: none$1(),
 		open: false,
 		lines: [],
@@ -150366,7 +149568,7 @@ var proseBlockOf = (markdown, source) => markdown.trim().length === 0 ? [] : [Pr
 	markdown: markdown.trim()
 })];
 var proseBlocks = (markdown, source) => {
-	const walked = reduce$11(fromIterable$15(markdown.matchAll(notePattern)), {
+	const walked = reduce$10(fromIterable$15(markdown.matchAll(notePattern)), {
 		blocks: [],
 		cursor: 0
 	}, (acc, match) => {
@@ -150503,7 +149705,7 @@ var toVolar = (vc) => ({
 	mappings: map$24(vc.mappings, toCodeMapping),
 	embeddedCodes: map$24(vc.embeddedCodes, toVolar)
 });
-var ignoredDir = /* @__PURE__ */ new Set([
+var ignoredDirs = /* @__PURE__ */ new Set([
 	"node_modules",
 	".loom",
 	"dist",
@@ -150518,7 +149720,7 @@ var entriesIn = (dir) => {
 };
 var loomsUnder = (dir) => flatMap$10(entriesIn(dir), (entry) => {
 	const full = resolve(dir, entry.name);
-	return value$1(entry).pipe(when((e) => ignoredDir.has(e.name), () => []), when((e) => e.isDirectory(), () => loomsUnder(full)), when((e) => e.name.endsWith(".loom"), () => [full]), orElse(() => []));
+	return value$1(entry).pipe(when((e) => ignoredDirs.has(e.name), () => []), when((e) => e.isDirectory(), () => loomsUnder(full)), when((e) => e.name.endsWith(".loom"), () => [full]), orElse(() => []));
 });
 var DocumentSource = class extends Service$1()("DocumentSource", { make: succeed$6({
 	read: (path) => try_({
@@ -150651,6 +149853,6 @@ var removeService = (id, dir) => sync$3(() => rmSync(join(storeDir(dir), "node_m
 	force: true
 }));
 //#endregion
-export { get$16 as $, filter$15 as $n, ignore$3 as $t, Boolean$1 as A, mergeAll$2 as An, identity$1 as Ar, makeUnsafe$12 as At, make$33 as B, fail$11 as Bn, catchTag$2 as Bt, errorReported as C, try_ as Cn, format$5 as Cr, endUnsafe as Ct, make$30 as D, TaggedError as Dn, isNullish as Dr, offerUnsafe as Dt, Crypto as E, catchDone as En, isNotUndefined as Er, offer$2 as Et, FileDescriptor as F, MinimumLogLevel as Fn, as$1 as Ft, isStream as G, fail$12 as Gn, ensuring$3 as Gt, decodeText as H, Done as Hn, catch_$3 as Ht, FileSystem as I, _await$1 as In, asVoid as It, run$4 as J, empty$20 as Jn, fnUntraced as Jt, merge$1 as K, Reference as Kn, fail$8 as Kt, FileTypeId as L, doneUnsafe as Ln, callback$2 as Lt, TrueValues as M, provideMerge as Mn, pipeArguments as Mr, acquireRelease$1 as Mt, Path as N, succeed$8 as Nn, addFinalizer as Nt, error$1 as O, taggedEnum as On, isUndefined$1 as Or, take$7 as Ot, TypeId$33 as P, addFinalizer$1 as Pn, andThen as Pt, unwrap$1 as Q, dedupe$1 as Qn, gen$1 as Qt, Size as R, isDone$1 as Rn, catchCause$3 as Rt, errorExitCode as S, tryPromise as Sn, BaseProto as Sr, mapDone as St, make$22 as T, void_$1 as Tn, isNotNull as Tr, make$48 as Tt, empty$9 as U, UnknownError as Un, die$3 as Ut, callback as V, succeed$10 as Vn, catchTags$1 as Vt, fromChannel as W, done$2 as Wn, effectify as Wt, splitLines$1 as X, make$69 as Xn, forever$2 as Xt, runCollect as Y, getUnsafe$11 as Yn, forEach$8 as Yt, transduce as Z, Prototype as Zn, forkScoped as Zt, Terminal as _, succeed$6 as _n, map$29 as _r, tag$2 as _t, storeDir as a, match$3 as an, of$2 as ar, badArgument as at, Stdio as b, tap$2 as bn, some$13 as br, get$21 as bt, LoomCompiler as c, orElseSucceed$1 as cn, fail$14 as cr, Defect as ct, PackageConfig as d, provideService$3 as dn, fromNullishOr$4 as dr, String$1 as dt, interrupt$3 as en, fromIterable$15 as er, make$35 as et, LoomConfig as f, raceFirst as fn, fromUndefinedOr as fr, Struct as ft, QuitError as g, serviceOption$1 as gn, isSome as gr, optional as gt, dist_exports as h, scoped$2 as hn, isNone as hr, is$2 as ht, servicePackage as i, mapError$3 as in, match$11 as ir, BadArgument as it, FalseValues as j, provide$5 as jn, pipe as jr, nominal as jt, log as k, effect as kn, dual as kr, make$50 as kt, loomsUnder as l, provide$3 as ln, succeed$12 as lr, ErrorClass as lt, ReadError as m, runFork as mn, getOrUndefined$2 as mr, decodeUnknownEffect as mt, installedServices as n, logWarning as nn, groupBy$1 as nr, fromChannel$1 as nt, workspaceRoot as o, matchEffect as on, reduce$11 as or, systemError as ot, SemanticTokenSchema as p, result$3 as pn, getOrElse$2 as pr, Union as pt, mkString as q, Service$1 as qn, flatMap$7 as qt, removeService as r, map$19 as rn, map$24 as rr, isSink as rt, DocumentSource as s, orDie$2 as sn, sort$1 as sr, ArraySchema as st, addService as t, isEffect as tn, getSomes as tr, drain$1 as tt, stringSnapshot as u, provideContext$3 as un, flatMap$13 as ur, Literal as ut, isQuitError as v, suspend$4 as vn, match$13 as vr, toCodecStringTree as vt, makeRunMain as w, uninterruptible as wn, hasProperty as wr, failCauseUnsafe as wt, make$13 as x, timeoutOrElse$1 as xn, String$5 as xr, fromTransform$1 as xt, make$11 as y, sync$3 as yn, none$1 as yr, fromIterable$10 as yt, WatchBackend as z, makeUnsafe$16 as zn, catchFilter$2 as zt };
+export { mkString as $, done$2 as $n, ensuring$3 as $t, log as A, timeoutOrElse$1 as An, none$1 as Ar, mapDone as At, WatchBackend as B, provide$5 as Bn, dual as Br, acquireRelease$1 as Bt, errorExitCode as C, runFork as Cn, fromUndefinedOr as Cr, is$2 as Ct, Crypto as D, suspend$4 as Dn, isSome as Dr, fromIterable$10 as Dt, make$22 as E, succeed$6 as En, isNone as Er, toCodecStringTree as Et, TypeId$33 as F, catchDone as Fn, hasProperty as Fr, offerUnsafe as Ft, empty$9 as G, _await$1 as Gn, callback$2 as Gt, callback as H, succeed$8 as Hn, pipe as Hr, andThen as Ht, FileDescriptor as I, TaggedError as In, isNotNull as Ir, take$7 as It, fromEffect$1 as J, makeUnsafe$16 as Jn, catchTag$2 as Jt, filter$5 as K, doneUnsafe as Kn, catchCause$3 as Kt, FileSystem as L, taggedEnum as Ln, isNotUndefined as Lr, make$50 as Lt, FalseValues as M, try_ as Mn, String$5 as Mr, failCauseUnsafe as Mt, TrueValues as N, uninterruptible as Nn, BaseProto as Nr, make$48 as Nt, make$30 as O, sync$3 as On, map$29 as Or, get$21 as Ot, Path as P, void_$1 as Pn, format$5 as Pr, offer$2 as Pt, merge$1 as Q, UnknownError as Qn, effectify as Qt, FileTypeId as R, effect as Rn, isNullish as Rr, makeUnsafe$12 as Rt, make$13 as S, result$3 as Sn, fromNullishOr$4 as Sr, decodeUnknownEffect as St, makeRunMain as T, serviceOption$1 as Tn, getOrUndefined$2 as Tr, tag$2 as Tt, concat$2 as U, addFinalizer$1 as Un, pipeArguments as Ur, as$1 as Ut, make$33 as V, provideMerge as Vn, identity$1 as Vr, addFinalizer as Vt, decodeText as W, MinimumLogLevel as Wn, asVoid as Wt, isStream as X, succeed$10 as Xn, catch_$3 as Xt, groupedWithin as Y, fail$11 as Yn, catchTags$1 as Yt, mapEffect as Z, Done as Zn, die$3 as Zt, QuitError as _, orElseSucceed$1 as _n, fail$14 as _r, ErrorClass as _t, storeDir as a, forkScoped as an, make$69 as ar, transduce as at, make$11 as b, provideService$3 as bn, contains$3 as br, Struct as bt, LoomCompiler as c, interrupt$3 as cn, filter$15 as cr, make$35 as ct, stringSnapshot as d, map$19 as dn, groupBy$1 as dr, isSink as dt, fail$8 as en, fail$12 as er, orDie as et, PackageConfig as f, mapError$3 as fn, map$24 as fr, BadArgument as ft, dist_exports as g, orDie$2 as gn, sort$1 as gr, Defect as gt, ReadError as h, option$4 as hn, reduce$10 as hr, ArraySchema as ht, servicePackage as i, forever$2 as in, getUnsafe$11 as ir, splitLines$1 as it, Boolean$1 as j, tryPromise as jn, some$13 as jr, endUnsafe as jt, error$1 as k, tap$2 as kn, match$13 as kr, fromTransform$1 as kt, ignoredDirs as l, isEffect as ln, fromIterable$15 as lr, drain$1 as lt, SemanticTokenSchema as m, matchEffect as mn, of$2 as mr, systemError as mt, installedServices as n, fnUntraced as nn, Service$1 as nr, runCollect as nt, workspaceRoot as o, gen$1 as on, Prototype as or, unwrap$1 as ot, LoomConfig as p, match$3 as pn, match$11 as pr, badArgument as pt, fromChannel as q, isDone$1 as qn, catchFilter$2 as qt, removeService as r, forEach$8 as rn, empty$20 as rr, runForEach as rt, DocumentSource as s, ignore$3 as sn, dedupe$1 as sr, get$16 as st, addService as t, flatMap$7 as tn, Reference as tr, run$4 as tt, loomsUnder as u, logWarning as un, getSomes as ur, fromChannel$1 as ut, Terminal as v, provide$3 as vn, match$12 as vr, Literal as vt, errorReported as w, scoped$2 as wn, getOrElse$2 as wr, optional as wt, Stdio as x, raceFirst as xn, flatMap$13 as xr, Union as xt, isQuitError as y, provideContext$3 as yn, succeed$12 as yr, String$1 as yt, Size as z, mergeAll$2 as zn, isUndefined$1 as zr, nominal as zt };
 
-//# sourceMappingURL=LoomStore-DMf2PkfP.js.map
+//# sourceMappingURL=LoomStore-CxUQqaPK.js.map