clanka 0.7.3 → 0.7.5

package/dist/bin/Stream-B5ebASRi.mjs

@@ -0,0 +1,2090 @@
+import { $r as exitVoid, A as ensuring$2, Ao as exitSucceed, As as identity, B as fnUntraced, Br as void_$2, C as catch_$2, Ci as suspend$3, Cn as isDoneCause, Co as Done, Ct as promise, Di as void_$1, Do as causeFail, Dr as interruptWith, Ds as constant, Dt as raceFirst, E as contextWith, Er as doneUnsafe, Es as constVoid, Et as provideService$2, Fr as interrupt$1, Fs as pipeArguments, G as forkIn, Gr as asSome, Gt as tap$1, H as forEach, I as flatMap$2, Ir as isExit, Ji as isArrayNonEmpty, K as forkScoped, Ki as fromIterable$1, Kr as callback$1, L as flatMapEager, Ln as findError, M as fail$3, N as failCause$2, Nn as die$2, Nr as fail$5, Nt as runForkWith, Oo as exitFail, Os as dual, Pa as get$1, Pn as done, Pr as failCause$3, Qr as exitInterrupt$1, Qt as uninterruptible, R as flatten$1, Ro as toJson, Rr as isSuccess, Rt as scopedWith, Si as succeedNone, Sn as filterDone, T as context, Ti as uninterruptibleMask, To as PipeInspectableProto, Tt as provideContext$2, U as forever, Ut as suspend$2, Vt as succeed$2, W as forkChild, Wr as andThen$1, Wt as sync, Xi as isReadonlyArrayNonEmpty, Y as gen, Yt as tryPromise, Z as interrupt$2, _r as forkUnsafe, _t as onExit$1, a as andThen, ai as fiberInterruptAs, an as whileLoop, bi as scopeFinalizerCountUnsafe, bn as catchDone, br as provide, c as as, ci as flatMap$3, da as isFailure, ea as map$3, ei as exitZipRight, fa as isSuccess$1, gr as close, gt as onError, hr as addFinalizerExit, ht as never, ii as fiberInterruptAllAs, in as when, j as exit, jo as withFiber$1, jr as makeUnsafe$3, ko as exitFailCause, lo as some, m as catchCause$1, ma as succeed$5, mi as makeLatchUnsafe, mr as addFinalizer, na as of, ni as fiberInterrupt, ns as hasProperty, oa as headUnsafe, oi as fiberJoin, on as withFiber, oo as none, ot as map$2, pi as makeLatch, pr as Scope, pt as matchCauseEffect, ri as fiberInterruptAll, rn as void_, sa as fail$4, si as fiberRunIn, t as acquireRelease, ti as fiberAwait, u as asVoid, ui as getCurrentFiber, un as yieldNow, vi as onExitPrimitive, vs as isString$1, wi as sync$1, wn as matchEffect, wr as _await, ws as constTrue, xi as succeed$4, xn as doneExitFromCause, yr as makeUnsafe$2, ys as isTagged, yt as onInterrupt, zr as succeed$3 } from "./Effect-DdkIoNCD.mjs";
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/count.js
+const normalize = (n) => n > 0 ? Math.floor(n) : 0;
+const normalizeNonEmpty = (n) => Math.max(1, normalize(n));
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Number.js
+const Number$1 = globalThis.Number;
+const nextPow2 = (n) => {
+	const nextPow = Math.ceil(Math.log(n) / Math.log(2));
+	return Math.max(Math.pow(2, nextPow), 2);
+};
+const parse = (s) => {
+	if (s === "NaN") return some(NaN);
+	if (s === "Infinity") return some(Infinity);
+	if (s === "-Infinity") return some(-Infinity);
+	if (s.trim() === "") return none();
+	const n = Number$1(s);
+	return Number$1.isNaN(n) ? none() : some(n);
+};
+const round = dual(2, (self, precision) => {
+	const factor = Math.pow(10, precision);
+	return Math.round(self * factor) / factor;
+});
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/String.js
+const String = globalThis.String;
+const isString = isString$1;
+const toLowerCase = (self) => self.toLowerCase();
+const camelToSnake = (self) => self.replace(/([A-Z])/g, "_$1").toLowerCase();
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Fiber.js
+const await_ = fiberAwait;
+const join = fiberJoin;
+const interrupt = fiberInterrupt;
+const interruptAs = fiberInterruptAs;
+const interruptAll = fiberInterruptAll;
+const interruptAllAs = fiberInterruptAllAs;
+const getCurrent = getCurrentFiber;
+const runIn = fiberRunIn;
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Latch.js
+const makeUnsafe$1 = makeLatchUnsafe;
+const make$5 = makeLatch;
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/MutableRef.js
+const TypeId$5 = "~effect/MutableRef";
+const MutableRefProto = {
+	[TypeId$5]: TypeId$5,
+	...PipeInspectableProto,
+	toJSON() {
+		return {
+			_id: "MutableRef",
+			current: toJson(this.current)
+		};
+	}
+};
+const make$4 = (value) => {
+	const ref = Object.create(MutableRefProto);
+	ref.current = value;
+	return ref;
+};
+const get = (self) => self.current;
+const set = dual(2, (self, value) => {
+	self.current = value;
+	return self;
+});
+const update = dual(2, (self, f) => set(self, f(get(self))));
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/MutableList.js
+const Empty = Symbol.for("effect/MutableList/Empty");
+const make$3 = () => ({
+	head: void 0,
+	tail: void 0,
+	length: 0
+});
+const emptyBucket = () => ({
+	array: [],
+	mutable: true,
+	offset: 0,
+	next: void 0
+});
+const append = (self, message) => {
+	if (!self.tail) self.head = self.tail = emptyBucket();
+	else if (!self.tail.mutable) {
+		self.tail.next = emptyBucket();
+		self.tail = self.tail.next;
+	}
+	self.tail.array.push(message);
+	self.length++;
+};
+const prepend = (self, message) => {
+	self.head = {
+		array: [message],
+		mutable: true,
+		offset: 0,
+		next: self.head
+	};
+	if (!self.tail) self.tail = self.head;
+	self.length++;
+};
+const appendAll = (self, messages) => appendAllUnsafe(self, fromIterable$1(messages), !Array.isArray(messages));
+const appendAllUnsafe = (self, messages, mutable = false) => {
+	if (messages.length === 0) return 0;
+	const chunk = {
+		array: messages,
+		mutable,
+		offset: 0,
+		next: void 0
+	};
+	if (self.head) self.tail = self.tail.next = chunk;
+	else self.head = self.tail = chunk;
+	self.length += messages.length;
+	return messages.length;
+};
+const clear = (self) => {
+	self.head = self.tail = void 0;
+	self.length = 0;
+};
+const takeN = (self, n) => {
+	n = normalize(n);
+	if (n <= 0 || !self.head) return [];
+	n = Math.min(n, self.length);
+	if (n === self.length && self.head?.offset === 0 && !self.head.next) {
+		const array = self.head.array;
+		clear(self);
+		return array;
+	}
+	const array = new Array(n);
+	let index = 0;
+	let chunk = self.head;
+	while (chunk) {
+		while (chunk.offset < chunk.array.length) {
+			array[index++] = chunk.array[chunk.offset];
+			if (chunk.mutable) chunk.array[chunk.offset] = void 0;
+			chunk.offset++;
+			if (index === n) {
+				self.head = chunk;
+				self.length -= n;
+				if (self.length === 0) clear(self);
+				return array;
+			}
+		}
+		chunk = chunk.next;
+	}
+	clear(self);
+	return array;
+};
+const takeAll$2 = (self) => takeN(self, self.length);
+const take$3 = (self) => {
+	if (!self.head) return Empty;
+	const message = self.head.array[self.head.offset];
+	if (self.head.mutable) self.head.array[self.head.offset] = void 0;
+	self.head.offset++;
+	self.length--;
+	if (self.head.offset === self.head.array.length) {
+		if (self.head.next) self.head = self.head.next;
+		else clear(self);
+	}
+	return message;
+};
+const filter$1 = (self, f) => {
+	const array = [];
+	let chunk = self.head;
+	while (chunk) {
+		for (let i = chunk.offset; i < chunk.array.length; i++) if (f(chunk.array[i], i)) array.push(chunk.array[i]);
+		chunk = chunk.next;
+	}
+	if (array.length === 0) {
+		clear(self);
+		return;
+	}
+	self.head = self.tail = {
+		array,
+		mutable: true,
+		offset: 0,
+		next: void 0
+	};
+	self.length = array.length;
+};
+const remove = (self, value) => filter$1(self, (v) => v !== value);
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/PubSub.js
+const TypeId$4 = "~effect/PubSub";
+const SubscriptionTypeId = "~effect/PubSub/Subscription";
+const make$2 = (options) => sync(() => makePubSubUnsafe(options.atomicPubSub(), new Map(), makeUnsafe$2(), makeUnsafe$1(false), make$4(false), options.strategy()));
+const bounded$1 = (capacity) => make$2({
+	atomicPubSub: () => makeAtomicBounded(capacity),
+	strategy: () => new BackPressureStrategy()
+});
+const dropping = (capacity) => make$2({
+	atomicPubSub: () => makeAtomicBounded(capacity),
+	strategy: () => new DroppingStrategy()
+});
+const sliding = (capacity) => make$2({
+	atomicPubSub: () => makeAtomicBounded(capacity),
+	strategy: () => new SlidingStrategy()
+});
+const unbounded$1 = (options) => make$2({
+	atomicPubSub: () => makeAtomicUnbounded(options),
+	strategy: () => new DroppingStrategy()
+});
+const makeAtomicBounded = (capacity) => {
+	const options = typeof capacity === "number" ? { capacity } : capacity;
+	ensureCapacity(options.capacity);
+	const replayBuffer = options.replay && options.replay > 0 ? new ReplayBuffer(Math.ceil(options.replay)) : void 0;
+	if (options.capacity === 1) return new BoundedPubSubSingle(replayBuffer);
+	else if (nextPow2(options.capacity) === options.capacity) return new BoundedPubSubPow2(options.capacity, replayBuffer);
+	else return new BoundedPubSubArb(options.capacity, replayBuffer);
+};
+const makeAtomicUnbounded = (options) => {
+	const replay = options?.replay;
+	return new UnboundedPubSub(replay && replay > 0 ? new ReplayBuffer(Math.ceil(replay)) : void 0);
+};
+const shutdown$1 = (self) => uninterruptible(withFiber((fiber) => {
+	set(self.shutdownFlag, true);
+	return close(self.scope, interrupt$1(fiber.id)).pipe(andThen(self.strategy.shutdown), when(self.shutdownHook.open), asVoid);
+}));
+const publish = dual(2, (self, value) => suspend$2(() => {
+	if (self.shutdownFlag.current) return succeed$2(false);
+	if (self.pubsub.publish(value)) {
+		self.strategy.completeSubscribersUnsafe(self.pubsub, self.subscribers);
+		return succeed$2(true);
+	}
+	return self.strategy.handleSurplus(self.pubsub, self.subscribers, [value], self.shutdownFlag);
+}));
+const publishAll = dual(2, (self, elements) => suspend$2(() => {
+	if (self.shutdownFlag.current) return succeed$2(false);
+	const surplus = self.pubsub.publishAll(elements);
+	self.strategy.completeSubscribersUnsafe(self.pubsub, self.subscribers);
+	if (surplus.length === 0) return succeed$2(true);
+	return self.strategy.handleSurplus(self.pubsub, self.subscribers, surplus, self.shutdownFlag);
+}));
+const subscribe = (self) => uninterruptible(contextWith((services) => {
+	const localScope = get$1(services, Scope);
+	const scope = forkUnsafe(self.scope);
+	const subscription = makeSubscriptionUnsafe(self.pubsub, self.subscribers, self.strategy);
+	return addFinalizer(scope, unsubscribe(subscription)).pipe(andThen(addFinalizerExit(localScope, (exit) => close(scope, exit))), as(subscription));
+}));
+const unsubscribe = (self) => uninterruptible(withFiber((state) => {
+	set(self.shutdownFlag, true);
+	return forEach(takeAll$2(self.pollers), (d) => interruptWith(d, state.id), {
+		discard: true,
+		concurrency: "unbounded"
+	}).pipe(tap$1(() => sync(() => {
+		self.subscribers.delete(self.subscription);
+		self.subscription.unsubscribe();
+		self.replayWindow.close();
+		self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
+	})), when(self.shutdownHook.open), asVoid);
+}));
+const take$2 = (self) => suspend$2(() => {
+	if (self.shutdownFlag.current) return interrupt$2;
+	if (self.replayWindow.remaining > 0) {
+		const message = self.replayWindow.take();
+		return succeed$2(message);
+	}
+	const message = self.pollers.length === 0 ? self.subscription.poll() : Empty;
+	if (message === Empty) return pollForItem(self);
+	else {
+		self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
+		return succeed$2(message);
+	}
+});
+const takeAll$1 = (self) => suspend$2(function loop(value) {
+	if (self.shutdownFlag.current) return interrupt$2;
+	let as = self.pollers.length === 0 ? self.subscription.pollUpTo(Number.POSITIVE_INFINITY) : [];
+	if (value) as = value.concat(as);
+	self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
+	if (self.replayWindow.remaining > 0) return succeed$2(self.replayWindow.takeAll().concat(as));
+	else if (!isArrayNonEmpty(as)) return flatMap$2(pollForItem(self), (item) => loop([item]));
+	return succeed$2(as);
+});
+const pollForItem = (self) => {
+	const deferred = makeUnsafe$3();
+	let set = self.subscribers.get(self.subscription);
+	if (!set) {
+		set = new Set();
+		self.subscribers.set(self.subscription, set);
+	}
+	set.add(self.pollers);
+	append(self.pollers, deferred);
+	self.strategy.completePollersUnsafe(self.pubsub, self.subscribers, self.subscription, self.pollers);
+	return onInterrupt(_await(deferred), () => {
+		remove(self.pollers, deferred);
+		return void_;
+	});
+};
+const AbsentValue = Symbol.for("effect/PubSub/AbsentValue");
+const addSubscribers = (subscribers, subscription, pollers) => {
+	if (!subscribers.has(subscription)) subscribers.set(subscription, new Set());
+	subscribers.get(subscription).add(pollers);
+};
+const removeSubscribers = (subscribers, subscription, pollers) => {
+	if (!subscribers.has(subscription)) return;
+	const set = subscribers.get(subscription);
+	set.delete(pollers);
+	if (set.size === 0) subscribers.delete(subscription);
+};
+const makeSubscriptionUnsafe = (pubsub, subscribers, strategy) => new SubscriptionImpl(pubsub, subscribers, pubsub.subscribe(), make$3(), makeUnsafe$1(false), make$4(false), strategy, pubsub.replayWindow());
+var BoundedPubSubArb = class {
+	array;
+	replayIndices;
+	publisherIndex = 0;
+	subscribers;
+	subscriberCount = 0;
+	subscribersIndex = 0;
+	capacity;
+	replayBuffer;
+	constructor(capacity, replayBuffer) {
+		this.capacity = capacity;
+		this.replayBuffer = replayBuffer;
+		this.array = Array.from({ length: capacity });
+		this.replayIndices = replayBuffer ? Array.from({ length: capacity }) : [];
+		this.subscribers = Array.from({ length: capacity });
+	}
+	replayWindow() {
+		return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+	}
+	isEmpty() {
+		return this.publisherIndex === this.subscribersIndex;
+	}
+	isFull() {
+		return this.publisherIndex === this.subscribersIndex + this.capacity;
+	}
+	size() {
+		return this.publisherIndex - this.subscribersIndex;
+	}
+	publish(value) {
+		if (this.isFull()) return false;
+		const replayIndex = this.replayBuffer?.offer(value);
+		if (this.subscriberCount !== 0) {
+			const index = this.publisherIndex % this.capacity;
+			this.array[index] = value;
+			if (replayIndex !== void 0) this.replayIndices[index] = replayIndex;
+			this.subscribers[index] = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return true;
+	}
+	publishAll(elements) {
+		if (this.subscriberCount === 0) {
+			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
+			return [];
+		}
+		const chunk = fromIterable$1(elements);
+		const n = chunk.length;
+		const size = this.publisherIndex - this.subscribersIndex;
+		const available = this.capacity - size;
+		const forPubSub = Math.min(n, available);
+		if (forPubSub === 0) return chunk;
+		let iteratorIndex = 0;
+		const publishAllIndex = this.publisherIndex + forPubSub;
+		while (this.publisherIndex !== publishAllIndex) {
+			const a = chunk[iteratorIndex++];
+			const index = this.publisherIndex % this.capacity;
+			this.array[index] = a;
+			const replayIndex = this.replayBuffer?.offer(a);
+			if (replayIndex !== void 0) this.replayIndices[index] = replayIndex;
+			this.subscribers[index] = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return chunk.slice(iteratorIndex);
+	}
+	slide() {
+		if (this.subscribersIndex !== this.publisherIndex) {
+			const index = this.subscribersIndex % this.capacity;
+			const value = this.array[index];
+			this.array[index] = AbsentValue;
+			this.subscribers[index] = 0;
+			this.subscribersIndex += 1;
+			this.replayBuffer?.slide(value, this.replayIndices[index]);
+		}
+	}
+	subscribe() {
+		this.subscriberCount += 1;
+		return new BoundedPubSubArbSubscription(this, this.publisherIndex, false);
+	}
+};
+var BoundedPubSubArbSubscription = class {
+	self;
+	subscriberIndex;
+	unsubscribed;
+	constructor(self, subscriberIndex, unsubscribed) {
+		this.self = self;
+		this.subscriberIndex = subscriberIndex;
+		this.unsubscribed = unsubscribed;
+	}
+	isEmpty() {
+		return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
+	}
+	size() {
+		if (this.unsubscribed) return 0;
+		return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+	}
+	poll() {
+		if (this.unsubscribed) return Empty;
+		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+		if (this.subscriberIndex !== this.self.publisherIndex) {
+			const index = this.subscriberIndex % this.self.capacity;
+			const elem = this.self.array[index];
+			this.self.subscribers[index] -= 1;
+			if (this.self.subscribers[index] === 0) {
+				this.self.array[index] = AbsentValue;
+				this.self.subscribersIndex += 1;
+			}
+			this.subscriberIndex += 1;
+			return elem;
+		}
+		return Empty;
+	}
+	pollUpTo(n) {
+		n = normalize(n);
+		if (this.unsubscribed) return [];
+		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+		const size = this.self.publisherIndex - this.subscriberIndex;
+		const toPoll = Math.min(n, size);
+		if (toPoll <= 0) return [];
+		const builder = [];
+		const pollUpToIndex = this.subscriberIndex + toPoll;
+		while (this.subscriberIndex !== pollUpToIndex) {
+			const index = this.subscriberIndex % this.self.capacity;
+			const a = this.self.array[index];
+			this.self.subscribers[index] -= 1;
+			if (this.self.subscribers[index] === 0) {
+				this.self.array[index] = AbsentValue;
+				this.self.subscribersIndex += 1;
+			}
+			builder.push(a);
+			this.subscriberIndex += 1;
+		}
+		return builder;
+	}
+	unsubscribe() {
+		if (!this.unsubscribed) {
+			this.unsubscribed = true;
+			this.self.subscriberCount -= 1;
+			this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+			while (this.subscriberIndex !== this.self.publisherIndex) {
+				const index = this.subscriberIndex % this.self.capacity;
+				this.self.subscribers[index] -= 1;
+				if (this.self.subscribers[index] === 0) {
+					this.self.array[index] = AbsentValue;
+					this.self.subscribersIndex += 1;
+				}
+				this.subscriberIndex += 1;
+			}
+		}
+	}
+};
+var BoundedPubSubPow2 = class {
+	array;
+	replayIndices;
+	mask;
+	publisherIndex = 0;
+	subscribers;
+	subscriberCount = 0;
+	subscribersIndex = 0;
+	capacity;
+	replayBuffer;
+	constructor(capacity, replayBuffer) {
+		this.capacity = capacity;
+		this.replayBuffer = replayBuffer;
+		this.array = Array.from({ length: capacity });
+		this.replayIndices = replayBuffer ? Array.from({ length: capacity }) : [];
+		this.mask = capacity - 1;
+		this.subscribers = Array.from({ length: capacity });
+	}
+	replayWindow() {
+		return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+	}
+	isEmpty() {
+		return this.publisherIndex === this.subscribersIndex;
+	}
+	isFull() {
+		return this.publisherIndex === this.subscribersIndex + this.capacity;
+	}
+	size() {
+		return this.publisherIndex - this.subscribersIndex;
+	}
+	publish(value) {
+		if (this.isFull()) return false;
+		const replayIndex = this.replayBuffer?.offer(value);
+		if (this.subscriberCount !== 0) {
+			const index = this.publisherIndex & this.mask;
+			this.array[index] = value;
+			if (replayIndex !== void 0) this.replayIndices[index] = replayIndex;
+			this.subscribers[index] = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return true;
+	}
+	publishAll(elements) {
+		if (this.subscriberCount === 0) {
+			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
+			return [];
+		}
+		const chunk = fromIterable$1(elements);
+		const n = chunk.length;
+		const size = this.publisherIndex - this.subscribersIndex;
+		const available = this.capacity - size;
+		const forPubSub = Math.min(n, available);
+		if (forPubSub === 0) return chunk;
+		let iteratorIndex = 0;
+		const publishAllIndex = this.publisherIndex + forPubSub;
+		while (this.publisherIndex !== publishAllIndex) {
+			const elem = chunk[iteratorIndex++];
+			const index = this.publisherIndex & this.mask;
+			this.array[index] = elem;
+			const replayIndex = this.replayBuffer?.offer(elem);
+			if (replayIndex !== void 0) this.replayIndices[index] = replayIndex;
+			this.subscribers[index] = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return chunk.slice(iteratorIndex);
+	}
+	slide() {
+		if (this.subscribersIndex !== this.publisherIndex) {
+			const index = this.subscribersIndex & this.mask;
+			const value = this.array[index];
+			this.array[index] = AbsentValue;
+			this.subscribers[index] = 0;
+			this.subscribersIndex += 1;
+			this.replayBuffer?.slide(value, this.replayIndices[index]);
+		}
+	}
+	subscribe() {
+		this.subscriberCount += 1;
+		return new BoundedPubSubPow2Subscription(this, this.publisherIndex, false);
+	}
+};
+var BoundedPubSubPow2Subscription = class {
+	self;
+	subscriberIndex;
+	unsubscribed;
+	constructor(self, subscriberIndex, unsubscribed) {
+		this.self = self;
+		this.subscriberIndex = subscriberIndex;
+		this.unsubscribed = unsubscribed;
+	}
+	isEmpty() {
+		return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
+	}
+	size() {
+		if (this.unsubscribed) return 0;
+		return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+	}
+	poll() {
+		if (this.unsubscribed) return Empty;
+		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+		if (this.subscriberIndex !== this.self.publisherIndex) {
+			const index = this.subscriberIndex & this.self.mask;
+			const elem = this.self.array[index];
+			this.self.subscribers[index] -= 1;
+			if (this.self.subscribers[index] === 0) {
+				this.self.array[index] = AbsentValue;
+				this.self.subscribersIndex += 1;
+			}
+			this.subscriberIndex += 1;
+			return elem;
+		}
+		return Empty;
+	}
+	pollUpTo(n) {
+		n = normalize(n);
+		if (this.unsubscribed) return [];
+		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+		const size = this.self.publisherIndex - this.subscriberIndex;
+		const toPoll = Math.min(n, size);
+		if (toPoll <= 0) return [];
+		const builder = [];
+		const pollUpToIndex = this.subscriberIndex + toPoll;
+		while (this.subscriberIndex !== pollUpToIndex) {
+			const index = this.subscriberIndex & this.self.mask;
+			const elem = this.self.array[index];
+			this.self.subscribers[index] -= 1;
+			if (this.self.subscribers[index] === 0) {
+				this.self.array[index] = AbsentValue;
+				this.self.subscribersIndex += 1;
+			}
+			builder.push(elem);
+			this.subscriberIndex += 1;
+		}
+		return builder;
+	}
+	unsubscribe() {
+		if (!this.unsubscribed) {
+			this.unsubscribed = true;
+			this.self.subscriberCount -= 1;
+			this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
+			while (this.subscriberIndex !== this.self.publisherIndex) {
+				const index = this.subscriberIndex & this.self.mask;
+				this.self.subscribers[index] -= 1;
+				if (this.self.subscribers[index] === 0) {
+					this.self.array[index] = AbsentValue;
+					this.self.subscribersIndex += 1;
+				}
+				this.subscriberIndex += 1;
+			}
+		}
+	}
+};
+var BoundedPubSubSingle = class {
+	publisherIndex = 0;
+	subscriberCount = 0;
+	subscribers = 0;
+	value = AbsentValue;
+	replayIndex = 0;
+	capacity = 1;
+	replayBuffer;
+	constructor(replayBuffer) {
+		this.replayBuffer = replayBuffer;
+	}
+	replayWindow() {
+		return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+	isEmpty() {
+		return this.subscribers === 0;
+	}
+	isFull() {
+		return !this.isEmpty();
+	}
+	size() {
+		return this.isEmpty() ? 0 : 1;
+	}
+	publish(value) {
+		if (this.isFull()) return false;
+		const replayIndex = this.replayBuffer?.offer(value);
+		if (this.subscriberCount !== 0) {
+			this.value = value;
+			if (replayIndex !== void 0) this.replayIndex = replayIndex;
+			this.subscribers = this.subscriberCount;
+			this.publisherIndex += 1;
+		}
+		return true;
+	}
+	publishAll(elements) {
+		if (this.subscriberCount === 0) {
+			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
+			return [];
+		}
+		const chunk = fromIterable$1(elements);
+		if (chunk.length === 0) return chunk;
+		if (this.publish(chunk[0])) return chunk.slice(1);
+		else return chunk;
+	}
+	slide() {
+		if (this.isFull()) {
+			const value = this.value;
+			this.subscribers = 0;
+			this.value = AbsentValue;
+			this.replayBuffer?.slide(value, this.replayIndex);
+		}
+	}
+	subscribe() {
+		this.subscriberCount += 1;
+		return new BoundedPubSubSingleSubscription(this, this.publisherIndex, false);
+	}
+};
+var BoundedPubSubSingleSubscription = class {
+	self;
+	subscriberIndex;
+	unsubscribed;
+	constructor(self, subscriberIndex, unsubscribed) {
+		this.self = self;
+		this.subscriberIndex = subscriberIndex;
+		this.unsubscribed = unsubscribed;
+	}
+	isEmpty() {
+		return this.unsubscribed || this.self.subscribers === 0 || this.subscriberIndex === this.self.publisherIndex;
+	}
+	size() {
+		return this.isEmpty() ? 0 : 1;
+	}
+	poll() {
+		if (this.isEmpty()) return Empty;
+		const elem = this.self.value;
+		this.self.subscribers -= 1;
+		if (this.self.subscribers === 0) this.self.value = AbsentValue;
+		this.subscriberIndex = this.self.publisherIndex;
+		return elem;
+	}
+	pollUpTo(n) {
+		if (normalize(n) < 1 || this.isEmpty()) return [];
+		return [this.poll()];
+	}
+	unsubscribe() {
+		if (!this.unsubscribed) {
+			this.unsubscribed = true;
+			this.self.subscriberCount -= 1;
+			if (this.self.subscribers !== 0 && this.subscriberIndex !== this.self.publisherIndex) {
+				this.self.subscribers -= 1;
+				if (this.self.subscribers === 0) this.self.value = AbsentValue;
+			}
+		}
+	}
+};
+var UnboundedPubSub = class {
+	publisherHead = {
+		value: AbsentValue,
+		replayIndex: void 0,
+		subscribers: 0,
+		next: null
+	};
+	publisherTail = this.publisherHead;
+	publisherIndex = 0;
+	subscribersIndex = 0;
+	capacity = Number.MAX_SAFE_INTEGER;
+	replayBuffer;
+	constructor(replayBuffer) {
+		this.replayBuffer = replayBuffer;
+	}
+	replayWindow() {
+		return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+	}
+	isEmpty() {
+		return this.publisherHead === this.publisherTail;
+	}
+	isFull() {
+		return false;
+	}
+	size() {
+		return this.publisherIndex - this.subscribersIndex;
+	}
+	publish(value) {
+		const replayIndex = this.replayBuffer?.offer(value);
+		const subscribers = this.publisherTail.subscribers;
+		if (subscribers !== 0) {
+			const node = {
+				value,
+				replayIndex,
+				subscribers,
+				next: null
+			};
+			this.publisherTail.next = node;
+			this.publisherTail = this.publisherTail.next;
+			this.publisherIndex += 1;
+		}
+		return true;
+	}
+	publishAll(elements) {
+		if (this.publisherTail.subscribers !== 0) for (const a of elements) this.publish(a);
+		else if (this.replayBuffer) this.replayBuffer.offerAll(elements);
+		return [];
+	}
+	slide() {
+		if (this.publisherHead !== this.publisherTail) {
+			const node = this.publisherHead.next;
+			const value = node.value;
+			this.publisherHead = this.publisherHead.next;
+			this.publisherHead.value = AbsentValue;
+			this.subscribersIndex += 1;
+			this.replayBuffer?.slide(value, node.replayIndex);
+		}
+	}
+	subscribe() {
+		this.publisherTail.subscribers += 1;
+		return new UnboundedPubSubSubscription(this, this.publisherTail, this.publisherIndex, false);
+	}
+};
+var UnboundedPubSubSubscription = class {
+	self;
+	subscriberHead;
+	subscriberIndex;
+	unsubscribed;
+	constructor(self, subscriberHead, subscriberIndex, unsubscribed) {
+		this.self = self;
+		this.subscriberHead = subscriberHead;
+		this.subscriberIndex = subscriberIndex;
+		this.unsubscribed = unsubscribed;
+	}
+	isEmpty() {
+		if (this.unsubscribed) return true;
+		let empty = true;
+		let loop = true;
+		while (loop) if (this.subscriberHead === this.self.publisherTail) loop = false;
+		else if (this.subscriberHead.next.value !== AbsentValue) {
+			empty = false;
+			loop = false;
+		} else {
+			this.subscriberHead = this.subscriberHead.next;
+			this.subscriberIndex += 1;
+		}
+		return empty;
+	}
+	size() {
+		if (this.unsubscribed) return 0;
+		return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+	}
+	poll() {
+		if (this.unsubscribed) return Empty;
+		let loop = true;
+		let polled = Empty;
+		while (loop) if (this.subscriberHead === this.self.publisherTail) loop = false;
+		else {
+			const elem = this.subscriberHead.next.value;
+			if (elem !== AbsentValue) {
+				polled = elem;
+				this.subscriberHead.subscribers -= 1;
+				if (this.subscriberHead.subscribers === 0) {
+					this.self.publisherHead = this.self.publisherHead.next;
+					this.self.publisherHead.value = AbsentValue;
+					this.self.subscribersIndex += 1;
+				}
+				loop = false;
+			}
+			this.subscriberHead = this.subscriberHead.next;
+			this.subscriberIndex += 1;
+		}
+		return polled;
+	}
+	pollUpTo(n) {
+		n = normalize(n);
+		const builder = [];
+		let i = 0;
+		while (i !== n) {
+			const a = this.poll();
+			if (a === Empty) i = n;
+			else {
+				builder.push(a);
+				i += 1;
+			}
+		}
+		return builder;
+	}
+	unsubscribe() {
+		if (!this.unsubscribed) {
+			this.unsubscribed = true;
+			this.self.publisherTail.subscribers -= 1;
+			while (this.subscriberHead !== this.self.publisherTail) {
+				if (this.subscriberHead.next.value !== AbsentValue) {
+					this.subscriberHead.subscribers -= 1;
+					if (this.subscriberHead.subscribers === 0) {
+						this.self.publisherHead = this.self.publisherHead.next;
+						this.self.publisherHead.value = AbsentValue;
+						this.self.subscribersIndex += 1;
+					}
+				}
+				this.subscriberHead = this.subscriberHead.next;
+			}
+		}
+	}
+};
+var SubscriptionImpl = class {
+	[SubscriptionTypeId] = { _A: identity };
+	pubsub;
+	subscribers;
+	subscription;
+	pollers;
+	shutdownHook;
+	shutdownFlag;
+	strategy;
+	replayWindow;
+	constructor(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy, replayWindow) {
+		this.pubsub = pubsub;
+		this.subscribers = subscribers;
+		this.subscription = subscription;
+		this.pollers = pollers;
+		this.shutdownHook = shutdownHook;
+		this.shutdownFlag = shutdownFlag;
+		this.strategy = strategy;
+		this.replayWindow = replayWindow;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+var PubSubImpl = class {
+	[TypeId$4] = { _A: identity };
+	pubsub;
+	subscribers;
+	scope;
+	shutdownHook;
+	shutdownFlag;
+	strategy;
+	constructor(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy) {
+		this.pubsub = pubsub;
+		this.subscribers = subscribers;
+		this.scope = scope;
+		this.shutdownHook = shutdownHook;
+		this.shutdownFlag = shutdownFlag;
+		this.strategy = strategy;
+	}
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+const makePubSubUnsafe = (pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy) => new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy);
+const ensureCapacity = (capacity) => {
+	if (capacity <= 0) throw new Error(`Cannot construct PubSub with capacity of ${capacity}`);
+};
+var BackPressureStrategy = class {
+	publishers = make$3();
+	get shutdown() {
+		return withFiber((fiber) => forEach(takeAll$2(this.publishers), ([_, deferred, last]) => last ? interruptWith(deferred, fiber.id) : void_, {
+			concurrency: "unbounded",
+			discard: true
+		}));
+	}
+	handleSurplus(pubsub, subscribers, elements, isShutdown) {
+		return suspend$2(() => {
+			const deferred = makeUnsafe$3();
+			this.offerUnsafe(elements, deferred);
+			this.onPubSubEmptySpaceUnsafe(pubsub, subscribers);
+			this.completeSubscribersUnsafe(pubsub, subscribers);
+			return (get(isShutdown) ? interrupt$2 : _await(deferred)).pipe(onInterrupt(() => {
+				this.removeUnsafe(deferred);
+				return void_;
+			}));
+		});
+	}
+	onPubSubEmptySpaceUnsafe(pubsub, subscribers) {
+		let keepPolling = true;
+		while (keepPolling && !pubsub.isFull()) {
+			const publisher = take$3(this.publishers);
+			if (publisher === Empty) keepPolling = false;
+			else {
+				const [value, deferred] = publisher;
+				const published = pubsub.publish(value);
+				if (published && publisher[2]) doneUnsafe(deferred, succeed$3(true));
+				else if (!published) prepend(this.publishers, publisher);
+				this.completeSubscribersUnsafe(pubsub, subscribers);
+			}
+		}
+	}
+	completePollersUnsafe(pubsub, subscribers, subscription, pollers) {
+		return strategyCompletePollersUnsafe(this, pubsub, subscribers, subscription, pollers);
+	}
+	completeSubscribersUnsafe(pubsub, subscribers) {
+		return strategyCompleteSubscribersUnsafe(this, pubsub, subscribers);
+	}
+	offerUnsafe(elements, deferred) {
+		const iterator = elements[Symbol.iterator]();
+		let next = iterator.next();
+		if (!next.done) while (1) {
+			const value = next.value;
+			next = iterator.next();
+			if (next.done) {
+				append(this.publishers, [
+					value,
+					deferred,
+					true
+				]);
+				break;
+			}
+			append(this.publishers, [
+				value,
+				deferred,
+				false
+			]);
+		}
+	}
+	removeUnsafe(deferred) {
+		filter$1(this.publishers, ([_, d]) => d !== deferred);
+	}
+};
+var DroppingStrategy = class {
+	get shutdown() {
+		return void_;
+	}
+	handleSurplus(_pubsub, _subscribers, _elements, _isShutdown) {
+		return succeed$2(false);
+	}
+	onPubSubEmptySpaceUnsafe(_pubsub, _subscribers) {}
+	completePollersUnsafe(pubsub, subscribers, subscription, pollers) {
+		return strategyCompletePollersUnsafe(this, pubsub, subscribers, subscription, pollers);
+	}
+	completeSubscribersUnsafe(pubsub, subscribers) {
+		return strategyCompleteSubscribersUnsafe(this, pubsub, subscribers);
+	}
+};
+var SlidingStrategy = class {
+	get shutdown() {
+		return void_;
+	}
+	handleSurplus(pubsub, subscribers, elements, _isShutdown) {
+		return sync(() => {
+			this.slidingPublishUnsafe(pubsub, elements);
+			this.completeSubscribersUnsafe(pubsub, subscribers);
+			return true;
+		});
+	}
+	onPubSubEmptySpaceUnsafe(_pubsub, _subscribers) {}
+	completePollersUnsafe(pubsub, subscribers, subscription, pollers) {
+		return strategyCompletePollersUnsafe(this, pubsub, subscribers, subscription, pollers);
+	}
+	completeSubscribersUnsafe(pubsub, subscribers) {
+		return strategyCompleteSubscribersUnsafe(this, pubsub, subscribers);
+	}
+	slidingPublishUnsafe(pubsub, elements) {
+		const it = elements[Symbol.iterator]();
+		let next = it.next();
+		if (!next.done && pubsub.capacity > 0) {
+			let a = next.value;
+			let loop = true;
+			while (loop) {
+				pubsub.slide();
+				const pub = pubsub.publish(a);
+				if (pub && (next = it.next()) && !next.done) a = next.value;
+				else if (pub) loop = false;
+			}
+		}
+	}
+};
+const strategyCompletePollersUnsafe = (strategy, pubsub, subscribers, subscription, pollers) => {
+	let keepPolling = true;
+	while (keepPolling && !subscription.isEmpty()) {
+		const poller = take$3(pollers);
+		if (poller === Empty) {
+			removeSubscribers(subscribers, subscription, pollers);
+			if (pollers.length === 0) keepPolling = false;
+			else addSubscribers(subscribers, subscription, pollers);
+		} else {
+			const pollResult = subscription.poll();
+			if (pollResult === Empty) prepend(pollers, poller);
+			else {
+				doneUnsafe(poller, succeed$3(pollResult));
+				strategy.onPubSubEmptySpaceUnsafe(pubsub, subscribers);
+			}
+		}
+	}
+};
+const strategyCompleteSubscribersUnsafe = (strategy, pubsub, subscribers) => {
+	for (const [subscription, pollersSet] of subscribers) for (const pollers of pollersSet) strategy.completePollersUnsafe(pubsub, subscribers, subscription, pollers);
+};
+var ReplayBuffer = class {
+	capacity;
+	head = {
+		value: AbsentValue,
+		index: 0,
+		next: null
+	};
+	tail = this.head;
+	slideValues = [];
+	size = 0;
+	index = 0;
+	publisherIndex = 0;
+	constructor(capacity) {
+		this.capacity = capacity;
+	}
+	slide(value, publisherIndex) {
+		this.slideValues[this.index % this.capacity] = {
+			value,
+			index: publisherIndex
+		};
+		this.index++;
+	}
+	offer(a) {
+		const index = this.publisherIndex++;
+		this.tail.value = a;
+		this.tail.index = index;
+		this.tail.next = {
+			value: AbsentValue,
+			index: 0,
+			next: null
+		};
+		this.tail = this.tail.next;
+		if (this.size === this.capacity) this.head = this.head.next;
+		else this.size += 1;
+		return index;
+	}
+	offerAll(as) {
+		for (const a of as) this.offer(a);
+	}
+};
+var ReplayWindowImpl = class {
+	buffer;
+	values;
+	index = 0;
+	remaining;
+	slideIndex;
+	newestIndex = -1;
+	constructor(buffer) {
+		this.buffer = buffer;
+		this.remaining = buffer.size;
+		this.slideIndex = buffer.index;
+		this.values = new Array(this.remaining);
+		let node = buffer.head;
+		for (let i = 0; i < this.remaining; i++) {
+			this.values[i] = node.value;
+			this.newestIndex = node.index;
+			node = node.next;
+		}
+	}
+	close() {
+		this.values.length = 0;
+		this.remaining = 0;
+	}
+	sync() {
+		const slides = this.buffer.index - this.slideIndex;
+		if (slides === 0 || this.remaining === 0) return;
+		const count = Math.min(slides, this.buffer.capacity);
+		const start = this.buffer.index - count;
+		for (let i = 0; i < count; i++) {
+			const entry = this.buffer.slideValues[(start + i) % this.buffer.capacity];
+			if (entry.index > this.newestIndex) {
+				this.index = (this.index + 1) % this.values.length;
+				this.values[(this.index + this.remaining - 1) % this.values.length] = entry.value;
+				this.newestIndex = entry.index;
+			}
+		}
+		this.slideIndex = this.buffer.index;
+	}
+	take() {
+		if (this.remaining === 0) return;
+		this.sync();
+		const value = this.values[this.index];
+		this.values[this.index] = AbsentValue;
+		this.index = (this.index + 1) % this.values.length;
+		this.remaining--;
+		if (this.remaining === 0) this.close();
+		return value;
+	}
+	takeN(n) {
+		n = normalize(n);
+		const len = Math.min(n, this.remaining);
+		const items = new Array(len);
+		for (let i = 0; i < len; i++) items[i] = this.take();
+		return items;
+	}
+	takeAll() {
+		return this.takeN(this.remaining);
+	}
+};
+const emptyReplayWindow = {
+	remaining: 0,
+	take: () => void 0,
+	takeN: () => [],
+	takeAll: () => [],
+	close: () => void 0
+};
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Queue.js
+const TypeId$3 = "~effect/Queue";
+const EnqueueTypeId = "~effect/Queue/Enqueue";
+const DequeueTypeId = "~effect/Queue/Dequeue";
+const variance = {
+	_A: identity,
+	_E: identity
+};
+const QueueProto = {
+	[TypeId$3]: variance,
+	[EnqueueTypeId]: variance,
+	[DequeueTypeId]: variance,
+	...PipeInspectableProto,
+	toJSON() {
+		return {
+			_id: "effect/Queue",
+			state: this.state._tag,
+			size: sizeUnsafe(this)
+		};
+	}
+};
+const make$1 = (options) => withFiber$1((fiber) => {
+	const self = Object.create(QueueProto);
+	self.dispatcher = fiber.currentDispatcher;
+	self.capacity = options?.capacity ?? Number.POSITIVE_INFINITY;
+	self.strategy = options?.strategy ?? "suspend";
+	self.messages = make$3();
+	self.scheduleRunning = false;
+	self.state = {
+		_tag: "Open",
+		takers: new Set(),
+		offers: new Set(),
+		awaiters: new Set()
+	};
+	return succeed$4(self);
+});
+const bounded = (capacity) => make$1({ capacity });
+const unbounded = () => make$1();
+const offer = (self, message) => suspend$3(() => {
+	if (self.state._tag !== "Open") return exitFalse;
+	else if (self.messages.length >= self.capacity) switch (self.strategy) {
+		case "dropping": return exitFalse;
+		case "suspend":
+			if (self.capacity <= 0 && self.state.takers.size > 0) {
+				append(self.messages, message);
+				releaseTakers(self);
+				return exitTrue;
+			}
+			return offerRemainingSingle(self, message);
+		case "sliding":
+			take$3(self.messages);
+			append(self.messages, message);
+			return exitTrue;
+	}
+	append(self.messages, message);
+	scheduleReleaseTaker(self);
+	return exitTrue;
+});
+const offerUnsafe = (self, message) => {
+	if (self.state._tag !== "Open") return false;
+	else if (self.messages.length >= self.capacity) {
+		if (self.strategy === "sliding") {
+			take$3(self.messages);
+			append(self.messages, message);
+			return true;
+		} else if (self.capacity <= 0 && self.state.takers.size > 0) {
+			append(self.messages, message);
+			releaseTakers(self);
+			return true;
+		}
+		return false;
+	}
+	append(self.messages, message);
+	scheduleReleaseTaker(self);
+	return true;
+};
+const offerAll = (self, messages) => suspend$3(() => {
+	if (self.state._tag !== "Open") return succeed$4(fromIterable$1(messages));
+	const remaining = offerAllUnsafe(self, messages);
+	if (remaining.length === 0) return exitSucceed([]);
+	else if (self.strategy === "dropping") return succeed$4(remaining);
+	return offerRemainingArray(self, remaining);
+});
+const offerAllUnsafe = (self, messages) => {
+	if (self.state._tag !== "Open") return fromIterable$1(messages);
+	else if (self.capacity === Number.POSITIVE_INFINITY || self.strategy === "sliding") {
+		appendAll(self.messages, messages);
+		if (self.strategy === "sliding") takeN(self.messages, self.messages.length - self.capacity);
+		scheduleReleaseTaker(self);
+		return [];
+	}
+	const free = self.capacity <= 0 ? self.state.takers.size : self.capacity - self.messages.length;
+	if (free === 0) return fromIterable$1(messages);
+	const remaining = [];
+	let i = 0;
+	for (const message of messages) {
+		if (i < free) append(self.messages, message);
+		else remaining.push(message);
+		i++;
+	}
+	scheduleReleaseTaker(self);
+	return remaining;
+};
+const fail$2 = (self, error) => failCause$1(self, causeFail(error));
+const failCause$1 = dual(2, (self, cause) => sync$1(() => failCauseUnsafe(self, cause)));
+const failCauseUnsafe = (self, cause) => {
+	if (self.state._tag !== "Open") return false;
+	const exit = exitFailCause(cause);
+	const fail = exitZipRight(exit, exitFailDone);
+	if (self.state.offers.size === 0 && self.messages.length === 0) {
+		finalize(self, fail);
+		return true;
+	}
+	self.state = {
+		...self.state,
+		_tag: "Closing",
+		exit: fail
+	};
+	return true;
+};
+const end = (self) => failCause$1(self, causeFail(Done()));
+const endUnsafe = (self) => failCauseUnsafe(self, causeFail(Done()));
+const shutdown = (self) => sync$1(() => {
+	if (self.state._tag === "Done") return true;
+	clear(self.messages);
+	const offers = self.state.offers;
+	finalize(self, self.state._tag === "Open" ? exitInterrupt : self.state.exit);
+	if (offers.size > 0) {
+		for (const entry of offers) if (entry._tag === "Single") entry.resume(exitFalse);
+		else entry.resume(exitSucceed(entry.remaining.slice(entry.offset)));
+		offers.clear();
+	}
+	return true;
+});
+const takeAll = (self) => takeBetween(self, 1, Number.POSITIVE_INFINITY);
+const takeBetween = (self, min, max) => {
+	min = normalize(min);
+	max = normalize(max);
+	return suspend$3(() => takeBetweenUnsafe(self, min, max) ?? andThen$1(awaitTake(self), takeBetween(self, 1, max)));
+};
+const take$1 = (self) => suspend$3(() => takeUnsafe(self) ?? andThen$1(awaitTake(self), take$1(self)));
+const poll = (self) => suspend$3(() => {
+	const result = takeUnsafe(self);
+	if (result === void 0) return succeed$4(none());
+	if (result._tag === "Success") return succeed$4(some(result.value));
+	return succeed$4(none());
+});
+const takeUnsafe = (self) => {
+	if (self.state._tag === "Done") return self.state.exit;
+	if (self.messages.length > 0) {
+		const message = take$3(self.messages);
+		releaseCapacity(self);
+		return exitSucceed(message);
+	} else if (self.capacity <= 0 && self.state.offers.size > 0) {
+		const message = takeOfferUnsafe(self.state.offers);
+		releaseCapacity(self);
+		return exitSucceed(message);
+	}
+};
+const sizeUnsafe = (self) => self.state._tag === "Done" ? 0 : self.messages.length;
+const exitFalse = exitSucceed(false);
+const exitTrue = exitSucceed(true);
+const exitFailDone = exitFail(Done());
+const exitInterrupt = exitInterrupt$1();
+const releaseTakers = (self) => {
+	if (self.state._tag === "Done" || self.state.takers.size === 0) return;
+	for (const taker of self.state.takers) {
+		self.state.takers.delete(taker);
+		taker(exitVoid);
+		if (self.messages.length === 0) break;
+	}
+};
+const scheduleReleaseTaker = (self) => {
+	if (self.scheduleRunning || self.state._tag === "Done" || self.state.takers.size === 0) return;
+	self.scheduleRunning = true;
+	self.dispatcher.scheduleTask(() => {
+		self.scheduleRunning = false;
+		releaseTakers(self);
+	}, 0);
+};
+const takeBetweenUnsafe = (self, min, max) => {
+	if (self.state._tag === "Done") return self.state.exit;
+	else if (max <= 0 || min <= 0) return exitSucceed([]);
+	else if (self.capacity <= 0 && self.messages.length === 0 && self.state.offers.size > 0) {
+		const messages = [takeOfferUnsafe(self.state.offers)];
+		releaseCapacity(self);
+		return exitSucceed(messages);
+	}
+	min = Math.min(min, self.capacity || 1);
+	if (min <= self.messages.length) {
+		const messages = takeN(self.messages, max);
+		releaseCapacity(self);
+		return exitSucceed(messages);
+	}
+};
+const offerRemainingSingle = (self, message) => {
+	return callback$1((resume) => {
+		if (self.state._tag !== "Open") return resume(exitFalse);
+		const entry = {
+			_tag: "Single",
+			message,
+			resume
+		};
+		self.state.offers.add(entry);
+		return sync$1(() => {
+			if (self.state._tag === "Open") self.state.offers.delete(entry);
+		});
+	});
+};
+const offerRemainingArray = (self, remaining) => {
+	return callback$1((resume) => {
+		if (self.state._tag !== "Open") return resume(exitSucceed(remaining));
+		const entry = {
+			_tag: "Array",
+			remaining,
+			offset: 0,
+			resume
+		};
+		self.state.offers.add(entry);
+		return sync$1(() => {
+			if (self.state._tag === "Open") self.state.offers.delete(entry);
+		});
+	});
+};
+const takeOfferUnsafe = (offers) => {
+	const entry = offers.values().next().value;
+	if (entry._tag === "Single") {
+		offers.delete(entry);
+		entry.resume(exitTrue);
+		return entry.message;
+	}
+	const message = entry.remaining[entry.offset++];
+	if (entry.offset === entry.remaining.length) {
+		offers.delete(entry);
+		entry.resume(exitSucceed([]));
+	}
+	return message;
+};
+const releaseCapacity = (self) => {
+	if (self.state._tag === "Done") return isDoneCause(self.state.exit.cause);
+	else if (self.state.offers.size === 0) {
+		if (self.state._tag === "Closing" && self.messages.length === 0) {
+			finalize(self, self.state.exit);
+			return isDoneCause(self.state.exit.cause);
+		}
+		return false;
+	}
+	for (const entry of self.state.offers) {
+		let n = self.capacity - self.messages.length;
+		if (n <= 0) break;
+		else if (entry._tag === "Single") {
+			append(self.messages, entry.message);
+			self.state.offers.delete(entry);
+			entry.resume(exitTrue);
+		} else {
+			for (; entry.offset < entry.remaining.length; entry.offset++) {
+				if (n === 0) return false;
+				append(self.messages, entry.remaining[entry.offset]);
+				n--;
+			}
+			self.state.offers.delete(entry);
+			entry.resume(exitSucceed([]));
+		}
+	}
+	return false;
+};
+const awaitTake = (self) => callback$1((resume) => {
+	if (self.state._tag === "Done") return resume(self.state.exit);
+	self.state.takers.add(resume);
+	return sync$1(() => {
+		if (self.state._tag !== "Done") self.state.takers.delete(resume);
+	});
+});
+const finalize = (self, exit) => {
+	if (self.state._tag === "Done") return;
+	const openState = self.state;
+	self.state = {
+		_tag: "Done",
+		exit
+	};
+	for (const taker of openState.takers) taker(exit);
+	openState.takers.clear();
+	for (const awaiter of openState.awaiters) awaiter(exit);
+	openState.awaiters.clear();
+};
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Semaphore.js
+const makeUnsafe = (permits) => new SemaphoreImpl(permits);
+const waitForPermits = (self, n, effect) => callback$1((resume) => {
+	if (self.free >= n) return resume(effect);
+	const observer = () => {
+		if (self.free < n) return;
+		self.waiters.delete(observer);
+		resume(effect);
+	};
+	self.waiters.add(observer);
+	return sync$1(() => {
+		self.waiters.delete(observer);
+	});
+});
+var SemaphoreImpl = class {
+	waiters = new Set();
+	taken = 0;
+	permits;
+	constructor(permits) {
+		this.permits = permits;
+	}
+	get free() {
+		return this.permits - this.taken;
+	}
+	take(n) {
+		const take = suspend$3(() => {
+			if (this.free < n) return waitForPermits(this, n, take);
+			this.taken += n;
+			return succeed$4(n);
+		});
+		return take;
+	}
+	takeIfAvailable(n) {
+		return suspend$3(() => {
+			if (this.free < n) return succeed$4(false);
+			this.taken += n;
+			return succeed$4(true);
+		});
+	}
+	releaseUnsafe(fiber, n) {
+		this.taken -= n;
+		if (this.waiters.size > 0) fiber.currentDispatcher.scheduleTask(() => {
+			for (const observer of this.waiters) {
+				if (this.free <= 0) break;
+				observer();
+			}
+		}, 0);
+		return this.free;
+	}
+	resize(permits) {
+		return withFiber$1((fiber) => {
+			this.permits = permits;
+			if (this.free < 0) return void_$1;
+			this.releaseUnsafe(fiber, 0);
+			return void_$1;
+		});
+	}
+	release(n) {
+		return withFiber$1((fiber) => succeed$4(this.releaseUnsafe(fiber, n)));
+	}
+	get releaseAll() {
+		return withFiber$1((fiber) => succeed$4(this.releaseUnsafe(fiber, this.taken)));
+	}
+	withPermits(n) {
+		return (self) => uninterruptibleMask((restore) => {
+			const acquire = suspend$3(() => {
+				if (this.free < n) {
+					const wait = waitForPermits(this, n, void_$1);
+					return flatMap$3(restore(wait), () => acquire);
+				}
+				this.taken += n;
+				return onExitPrimitive(restore(self), () => {
+					this.releaseUnsafe(getCurrentFiber(), n);
+				}, true);
+			});
+			return acquire;
+		});
+	}
+	withPermit = this.withPermits(1);
+	withPermitsIfAvailable(n) {
+		return (self) => uninterruptibleMask((restore) => {
+			if (this.free < n) return succeedNone;
+			this.taken += n;
+			return onExitPrimitive(restore(asSome(self)), () => {
+				this.releaseUnsafe(getCurrentFiber(), n);
+			}, true);
+		});
+	}
+};
+const make = (permits) => sync$1(() => new SemaphoreImpl(permits));
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Take.js
+const toPull = (take) => isExit(take) ? isSuccess(take) ? done(take.value) : take : succeed$2(take);
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Channel.js
+const TypeId$2 = "~effect/Channel";
+const isChannel = (u) => hasProperty(u, TypeId$2);
+const ChannelProto = {
+	[TypeId$2]: {
+		_Env: identity,
+		_InErr: identity,
+		_InElem: identity,
+		_OutErr: identity,
+		_OutElem: identity
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+const fromTransform = (transform) => {
+	const self = Object.create(ChannelProto);
+	self.transform = (upstream, scope) => catchCause$1(transform(upstream, scope), (cause) => succeed$2(failCause$2(cause)));
+	return self;
+};
+const transformPull$1 = (self, f) => fromTransform((upstream, scope) => flatMap$2(toTransform(self)(upstream, scope), (pull) => f(pull, scope)));
+const fromPull$1 = (effect) => fromTransform((_, __) => effect);
+const fromTransformBracket = (f) => fromTransform(fnUntraced(function* (upstream, scope) {
+	const closableScope = forkUnsafe(scope);
+	const onCause = (cause) => close(closableScope, doneExitFromCause(cause));
+	const pull = yield* onError(f(upstream, scope, closableScope), onCause);
+	return onError(pull, onCause);
+}));
+const toTransform = (channel) => channel.transform;
+const DefaultChunkSize = 4096;
+const asyncQueue = (scope, f, options) => make$1({
+	capacity: options?.bufferSize,
+	strategy: options?.strategy
+}).pipe(tap$1((queue) => addFinalizer(scope, shutdown(queue))), tap$1((queue) => forkIn(provide(f(queue), scope), scope)));
+const callbackArray = (f, options) => fromTransform((_, scope) => map$2(asyncQueue(scope, f, options), takeAll));
+const suspend$1 = (evaluate) => fromTransform((upstream, scope) => suspend$2(() => toTransform(evaluate())(upstream, scope)));
+const fromIteratorArray = (iterator, chunkSize = DefaultChunkSize) => {
+	const size = normalizeNonEmpty(chunkSize);
+	return fromPull$1(sync(() => {
+		const iter = iterator();
+		let done$14 = none();
+		return suspend$2(() => {
+			if (done$14._tag === "Some") return done(done$14.value);
+			const buffer = [];
+			while (buffer.length < size) {
+				const state = iter.next();
+				if (state.done) {
+					if (buffer.length === 0) return done(state.value);
+					done$14 = some(state.value);
+					break;
+				}
+				buffer.push(state.value);
+			}
+			return succeed$2(buffer);
+		});
+	}));
+};
+const fromIterableArray = (iterable, chunkSize = DefaultChunkSize) => fromIteratorArray(() => iterable[Symbol.iterator](), chunkSize);
+const succeed$1 = (value) => fromEffect$1(succeed$2(value));
+const empty$1 = fromPull$1(succeed$2(done()));
+const fail$1 = (error) => fromPull$1(succeed$2(fail$3(error)));
+const failCause = (cause) => fromPull$1(failCause$2(cause));
+const die$1 = (defect) => failCause(die$2(defect));
+const fromEffect$1 = (effect) => fromPull$1(sync(() => {
+	let done$15 = false;
+	return suspend$2(() => {
+		if (done$15) return done();
+		done$15 = true;
+		return effect;
+	});
+}));
+const fromEffectTake = (effect) => fromPull$1(succeed$2(flatMap$2(effect, toPull)));
+const fromQueueArray = (queue) => fromPull$1(succeed$2(takeAll(queue)));
+const fromSubscriptionArray = (subscription) => fromPull$1(succeed$2(onInterrupt(takeAll$1(subscription), () => done())));
+const fromPubSubArray = (pubsub) => unwrap$1(map$2(subscribe(pubsub), fromSubscriptionArray));
+const fromPubSubTake$1 = (pubsub) => unwrap$1(map$2(subscribe(pubsub), (sub) => fromEffectTake(take$2(sub))));
+const fromReadableStream$1 = (options) => fromTransform((_, scope) => readableStreamToPullUnsafe({
+	scope,
+	readable: options.evaluate(),
+	onError: options.onError,
+	releaseLockOnEnd: options.releaseLockOnEnd
+}));
+const readableStreamToPullUnsafe = (options) => {
+	const reader = options.readable.getReader();
+	const exit = options.exit ?? make$4(void 0);
+	const pull = suspend$2(() => {
+		if (exit.current) return exit.current;
+		return matchCauseEffect(tryPromise({
+			try: () => reader.read(),
+			catch: options.onError
+		}), {
+			onFailure: (cause) => exit.current ?? failCause$2(cause),
+			onSuccess: ({ done: done$10, value }) => {
+				if (exit.current) return exit.current;
+				return done$10 ? done() : succeed$2(of(value));
+			}
+		});
+	});
+	return as(addFinalizer(options.scope, options.releaseLockOnEnd ? sync(() => reader.releaseLock()) : promise(() => reader.cancel().catch(constVoid))), pull);
+};
+const map$1 = dual(2, (self, f) => transformPull$1(self, (pull) => sync(() => {
+	let i = 0;
+	return map$2(pull, (o) => f(o, i++));
+})));
+const mapDone = dual(2, (self, f) => mapDoneEffect(self, (o) => succeed$2(f(o))));
+const mapDoneEffect = dual(2, (self, f) => transformPull$1(self, (pull) => succeed$2(catchDone(pull, (done$11) => flatMap$2(f(done$11), done)))));
+const concurrencyIsSequential = (concurrency) => concurrency === void 0 || concurrency !== "unbounded" && concurrency <= 1;
+const mapEffect$1 = dual((args) => isChannel(args[0]), (self, f, options) => concurrencyIsSequential(options?.concurrency) ? mapEffectSequential(self, f) : mapEffectConcurrent(self, f, options));
+const mapEffectSequential = (self, f) => fromTransform((upstream, scope) => {
+	let i = 0;
+	return map$2(toTransform(self)(upstream, scope), flatMap$2((o) => f(o, i++)));
+});
+const mapEffectConcurrent = (self, f, options) => fromTransformBracket(fnUntraced(function* (upstream, scope, forkedScope) {
+	let i = 0;
+	const pull = yield* toTransform(self)(upstream, scope);
+	const concurrencyN = options.concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : options.concurrency;
+	const queue = yield* bounded(0);
+	yield* addFinalizer(forkedScope, shutdown(queue));
+	const runFork = runForkWith(yield* context());
+	const trackFiber = runIn(forkedScope);
+	if (options.unordered) {
+		const semaphore = makeUnsafe(concurrencyN);
+		const release = constant(semaphore.release(1));
+		const handle = matchCauseEffect({
+			onFailure: (cause) => flatMap$2(failCause$1(queue, cause), release),
+			onSuccess: (value) => flatMap$2(offer(queue, value), release)
+		});
+		yield* semaphore.take(1).pipe(flatMap$2(() => pull), flatMap$2((value) => {
+			trackFiber(runFork(handle(f(value, i++))));
+			return void_;
+		}), forever({ disableYield: true }), catchCause$1((cause) => semaphore.withPermits(concurrencyN - 1)(failCause$1(queue, cause))), forkIn(forkedScope));
+	} else {
+		const effects = yield* bounded(concurrencyN - 2);
+		yield* addFinalizer(forkedScope, shutdown(effects));
+		yield* take$1(effects).pipe(flatten$1, flatMap$2((value) => offer(queue, value)), forever({ disableYield: true }), catchCause$1((cause) => failCause$1(queue, cause)), forkIn(forkedScope));
+		let errorCause;
+		const onExit = (exit) => {
+			if (exit._tag === "Success") return;
+			errorCause = exit.cause;
+			failCauseUnsafe(queue, exit.cause);
+		};
+		yield* pull.pipe(flatMap$2((value) => {
+			if (errorCause) return failCause$2(errorCause);
+			const fiber = runFork(f(value, i++));
+			trackFiber(fiber);
+			fiber.addObserver(onExit);
+			return offer(effects, join(fiber));
+		}), forever({ disableYield: true }), catchCause$1((cause) => offer(effects, failCause$3(cause)).pipe(andThen(failCause$1(effects, cause)))), forkIn(forkedScope));
+	}
+	return take$1(queue);
+}));
+const flatMap$1 = dual((args) => isChannel(args[0]), (self, f, options) => concurrencyIsSequential(options?.concurrency) ? flatMapSequential(self, f) : flatMapConcurrent(self, f, options));
+const flatMapSequential = (self, f) => fromTransform((upstream, scope) => map$2(toTransform(self)(upstream, scope), (pull) => {
+	let childPull;
+	let childScope;
+	const makePull = flatMap$2(pull, (value) => {
+		childScope ??= forkUnsafe(scope);
+		return flatMapEager(toTransform(f(value))(upstream, childScope), (pull) => {
+			childPull = catchHalt(pull);
+			return childPull;
+		});
+	});
+	const catchHalt = catchDone((_) => {
+		childPull = void 0;
+		if (childScope.state._tag === "Open" && scopeFinalizerCountUnsafe(childScope) === 1) return makePull;
+		const close$2 = close(childScope, void_$2);
+		childScope = void 0;
+		return flatMap$2(close$2, () => makePull);
+	});
+	return suspend$2(() => childPull ?? makePull);
+}));
+const flatMapConcurrent = (self, f, options) => self.pipe(map$1(f), mergeAll$1(options));
+const flattenArray = (self) => transformPull$1(self, (pull) => {
+	let array;
+	let index = 0;
+	const pump = suspend$2(function loop() {
+		if (array === void 0) return flatMap$2(pull, (array_) => {
+			switch (array_.length) {
+				case 0: return loop();
+				case 1: return succeed$2(array_[0]);
+				default:
+					array = array_;
+					return succeed$2(array_[index++]);
+			}
+		});
+		const next = array[index++];
+		if (index >= array.length) {
+			array = void 0;
+			index = 0;
+		}
+		return succeed$2(next);
+	});
+	return succeed$2(pump);
+});
+const filterArray = dual(2, (self, predicate) => transformPull$1(self, (pull) => succeed$2(flatMap$2(pull, function loop(arr) {
+	const passes = [];
+	for (let i = 0; i < arr.length; i++) if (predicate(arr[i])) passes.push(arr[i]);
+	return isReadonlyArrayNonEmpty(passes) ? succeed$2(passes) : flatMap$2(pull, loop);
+}))));
+const filterMapArray = dual(2, (self, filter) => transformPull$1(self, (pull) => succeed$2(flatMap$2(pull, function loop(arr) {
+	const passes = [];
+	for (let i = 0; i < arr.length; i++) {
+		const result = filter(arr[i]);
+		if (isSuccess$1(result)) passes.push(result.success);
+	}
+	return isReadonlyArrayNonEmpty(passes) ? succeed$2(passes) : flatMap$2(pull, loop);
+}))));
+const catchCause = dual(2, (self, f) => fromTransform((upstream, scope) => {
+	let forkedScope = forkUnsafe(scope);
+	return map$2(toTransform(self)(upstream, forkedScope), (pull) => {
+		let currentPull = pull.pipe(catchCause$1((cause) => {
+			if (isDoneCause(cause)) return failCause$2(cause);
+			const toClose = forkedScope;
+			forkedScope = forkUnsafe(scope);
+			return close(toClose, failCause$3(cause)).pipe(andThen(toTransform(f(cause))(upstream, forkedScope)), flatMap$2((childPull) => {
+				currentPull = childPull;
+				return childPull;
+			}));
+		}));
+		return suspend$2(() => currentPull);
+	});
+}));
+const catchCauseFilter = dual(3, (self, filter, f) => catchCause(self, (cause) => {
+	const result = filter(cause);
+	return isFailure(result) ? failCause(result.failure) : f(result.success, cause);
+}));
+const catch_$1 = dual(2, (self, f) => catchCauseFilter(self, findError, (e) => f(e)));
+const catchIf$1 = dual((args) => isChannel(args[0]), (self, predicate, f, orElse) => catch_$1(self, (err) => {
+	return predicate(err) ? f(err) : orElse ? orElse(err) : fail$1(err);
+}));
+const catchFilter$1 = dual((args) => isChannel(args[0]), (self, filter, f, orElse) => catch_$1(self, (err) => {
+	const result = filter(err);
+	return isFailure(result) ? orElse ? orElse(result.failure) : fail$1(result.failure) : f(result.success);
+}));
+const catchReason$1 = dual((args) => isChannel(args[0]), (self, errorTag, reasonTag, f, orElse) => catch_$1(self, (error) => {
+	if (isTagged(error, errorTag) && hasProperty(error, "reason")) {
+		const reason = error.reason;
+		if (isTagged(reason, reasonTag)) return f(reason, error);
+		return orElse ? orElse(reason, error) : fail$1(error);
+	}
+	return fail$1(error);
+}));
+const mapError$1 = dual(2, (self, f) => catch_$1(self, (err) => fail$1(f(err))));
+const orDie$1 = (self) => catch_$1(self, die$1);
+const mergeAll$1 = dual(2, (channels, { bufferSize = 16, concurrency, switch: switch_ = false }) => fromTransformBracket(fnUntraced(function* (upstream, scope, forkedScope) {
+	const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : Math.max(1, concurrency);
+	const semaphore = switch_ ? void 0 : makeUnsafe(concurrencyN);
+	const doneLatch = yield* make$5(true);
+	const fibers = new Set();
+	const queue = yield* bounded(bufferSize);
+	yield* addFinalizer(forkedScope, shutdown(queue));
+	const pull = yield* toTransform(channels)(upstream, scope);
+	yield* gen(function* () {
+		while (true) {
+			let pullFiber;
+			if (semaphore) {
+				if (fibers.size < concurrencyN) yield* semaphore.take(1);
+				else {
+					pullFiber = yield* forkChild(pull);
+					yield* raceFirst(semaphore.take(1), andThen(join(pullFiber), never));
+				}
+			}
+			const channel = pullFiber === void 0 ? yield* pull : yield* join(pullFiber);
+			const childScope = forkUnsafe(forkedScope);
+			const childPull = yield* toTransform(channel)(upstream, childScope);
+			while (fibers.size >= concurrencyN) {
+				const fiber = headUnsafe(fibers);
+				fibers.delete(fiber);
+				if (fibers.size === 0) yield* doneLatch.open;
+				yield* interrupt(fiber);
+			}
+			const fiber = yield* childPull.pipe(tap$1(() => yieldNow), flatMap$2((value) => offer(queue, value)), forever({ disableYield: true }), onError(fnUntraced(function* (cause) {
+				const halt = filterDone(cause);
+				yield* exit(close(childScope, !isFailure(halt) ? succeed$3(halt.success.value) : failCause$3(halt.failure)));
+				if (!fibers.has(fiber)) return;
+				fibers.delete(fiber);
+				if (semaphore) yield* semaphore.release(1);
+				if (fibers.size === 0) yield* doneLatch.open;
+				if (isSuccess$1(halt)) return;
+				return yield* failCause$1(queue, cause);
+			})), forkChild);
+			doneLatch.closeUnsafe();
+			fibers.add(fiber);
+		}
+	}).pipe(catchCause$1((cause) => {
+		const halt = filterDone(cause);
+		if (isSuccess$1(halt)) return doneLatch.whenOpen(failCause$1(queue, cause));
+		return failCause$1(queue, cause);
+	}), forkIn(forkedScope));
+	return take$1(queue);
+})));
+const merge$1 = dual((args) => isChannel(args[0]) && isChannel(args[1]), (left, right, options) => fromTransformBracket(fnUntraced(function* (upstream, _scope, forkedScope) {
+	const strategy = options?.haltStrategy ?? "both";
+	const queue = yield* bounded(0);
+	yield* addFinalizer(forkedScope, shutdown(queue));
+	let done = 0;
+	function onExit(side, cause) {
+		done++;
+		if (!isDoneCause(cause)) return failCause$1(queue, cause);
+		switch (strategy) {
+			case "both": return done === 2 ? failCause$1(queue, cause) : void_;
+			case "left":
+			case "right": return side === strategy ? failCause$1(queue, cause) : void_;
+			case "either": return failCause$1(queue, cause);
+		}
+	}
+	const runSide = (side, channel, scope) => toTransform(channel)(upstream, scope).pipe(flatMap$2((pull) => pull.pipe(flatMap$2((value) => offer(queue, value)), forever)), onError((cause) => andThen(close(scope, doneExitFromCause(cause)), onExit(side, cause))), forkIn(forkedScope));
+	yield* runSide("left", left, forkUnsafe(forkedScope));
+	yield* runSide("right", right, forkUnsafe(forkedScope));
+	return take$1(queue);
+})));
+const splitLines$1 = () => fromTransform((upstream, _scope) => sync(() => {
+	let stringBuilder = "";
+	let midCRLF = false;
+	let done$12 = none();
+	function splitLinesArray(chunk) {
+		const chunkBuilder = [];
+		function pushLine(segment) {
+			if (stringBuilder.length === 0) chunkBuilder.push(segment);
+			else {
+				chunkBuilder.push(stringBuilder + segment);
+				stringBuilder = "";
+			}
+		}
+		for (let i = 0; i < chunk.length; i++) {
+			const str = chunk[i];
+			if (str.length !== 0) {
+				let from = 0;
+				let indexOfCR = str.indexOf("\r");
+				let indexOfLF = str.indexOf("\n");
+				if (midCRLF) {
+					if (indexOfLF === 0) {
+						from = 1;
+						indexOfLF = str.indexOf("\n", from);
+					}
+					midCRLF = false;
+				}
+				while (indexOfCR !== -1 || indexOfLF !== -1) if (indexOfCR === -1 || indexOfLF !== -1 && indexOfLF < indexOfCR) {
+					pushLine(str.substring(from, indexOfLF));
+					from = indexOfLF + 1;
+					indexOfLF = str.indexOf("\n", from);
+				} else {
+					pushLine(str.substring(from, indexOfCR));
+					if (str.length === indexOfCR + 1) {
+						midCRLF = true;
+						from = str.length;
+						indexOfCR = -1;
+					} else {
+						from = indexOfCR + (indexOfLF === indexOfCR + 1 ? 2 : 1);
+						indexOfCR = str.indexOf("\r", from);
+						indexOfLF = str.indexOf("\n", from);
+					}
+				}
+				stringBuilder = stringBuilder + str.substring(from);
+			}
+		}
+		return isReadonlyArrayNonEmpty(chunkBuilder) ? chunkBuilder : null;
+	}
+	const pullOrFlush = suspend$2(() => {
+		if (done$12._tag === "Some") return done(done$12.value);
+		return matchEffect(upstream, {
+			onSuccess: loop,
+			onFailure: failCause$2,
+			onDone: (leftover) => {
+				done$12 = some(leftover);
+				if (stringBuilder.length > 0) {
+					const last = stringBuilder;
+					stringBuilder = "";
+					midCRLF = false;
+					return succeed$2([last]);
+				}
+				return done(leftover);
+			}
+		});
+	});
+	function loop(chunk) {
+		const lines = splitLinesArray(chunk);
+		return lines !== null ? succeed$2(lines) : pullOrFlush;
+	}
+	return pullOrFlush;
+}));
+const pipeTo = dual(2, (self, that) => fromTransform((upstream, scope) => flatMap$2(toTransform(self)(upstream, scope), (upstream) => toTransform(that)(upstream, scope))));
+const unwrap$1 = (channel) => fromTransform((upstream, scope) => {
+	let pull;
+	return succeed$2(suspend$2(() => {
+		if (pull) return pull;
+		return channel.pipe(provide(scope), flatMap$2((channel) => toTransform(channel)(upstream, scope)), flatMap$2((pull_) => pull = pull_));
+	}));
+});
+const onExit = dual(2, (self, finalizer) => fromTransformBracket((upstream, scope, forkedScope) => addFinalizerExit(forkedScope, finalizer).pipe(andThen(toTransform(self)(upstream, scope)))));
+const onEnd$1 = dual(2, (self, onEnd) => transformPull$1(self, (pull) => succeed$2(catchDone(pull, (leftover) => flatMap$2(onEnd, () => done(leftover))))));
+const ensuring$1 = dual(2, (self, finalizer) => onExit(self, (_) => finalizer));
+const runWith = (self, f, onHalt) => suspend$2(() => {
+	const scope = makeUnsafe$2();
+	const makePull = toTransform(self)(done(), scope);
+	return catchDone(flatMap$2(makePull, f), onHalt ? onHalt : succeed$2).pipe(onExit$1((exit) => close(scope, exit)));
+});
+const provideContext$1 = dual(2, (self, context) => fromTransform((upstream, scope) => map$2(provideContext$2(toTransform(self)(upstream, scope), context), provideContext$2(context))));
+const provideService$1 = dual(3, (self, key, service) => fromTransform((upstream, scope) => map$2(provideService$2(toTransform(self)(upstream, scope), key, service), provideService$2(key, service))));
+const runDrain$1 = (self) => runWith(self, (pull) => forever(pull, { disableYield: true }));
+const runForEach$1 = dual(2, (self, f) => runWith(self, (pull) => forever(flatMap$2(pull, f), { disableYield: true })));
+const runFold$1 = dual(3, (self, initial, f) => suspend$2(() => {
+	let state = initial();
+	return runWith(self, (pull) => whileLoop({
+		while: constTrue,
+		body: () => pull,
+		step: (value) => {
+			state = f(state, value);
+		}
+	}), () => succeed$2(state));
+}));
+const toPullScoped = (self, scope) => toTransform(self)(done(), scope);
+const makePubSub = (options) => acquireRelease(options.capacity === "unbounded" ? unbounded$1(options) : options.strategy === "dropping" ? dropping(options) : options.strategy === "sliding" ? sliding(options) : bounded$1(options), shutdown$1);
+const runIntoPubSubArray = dual((args) => isChannel(args[0]), (self, pubsub, options) => runForEach$1(self, (value) => publishAll(pubsub, value)).pipe(options?.shutdownOnEnd === true ? ensuring$2(shutdown$1(pubsub)) : identity));
+const toPubSubTake$1 = dual(2, fnUntraced(function* (self, options) {
+	const pubsub = yield* makePubSub(options);
+	yield* runForEach$1(self, (value) => publish(pubsub, value)).pipe(onExit$1((exit) => publish(pubsub, exit)), forkScoped);
+	return pubsub;
+}));
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/internal/stream.js
+const TypeId$1 = "~effect/Stream";
+const streamVariance = {
+	_R: identity,
+	_E: identity,
+	_A: identity
+};
+const Stream = function(channel) {
+	this.channel = channel;
+};
+Stream.prototype = {
+	[TypeId$1]: streamVariance,
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+const fromChannel$1 = (channel) => new Stream(channel);
+//#endregion
+//#region node_modules/.pnpm/effect@4.0.0-rc.115/node_modules/effect/dist/Stream.js
+const TypeId = "~effect/Stream";
+const isStream = (u) => hasProperty(u, TypeId);
+const fromChannel = fromChannel$1;
+const fromEffect = (effect) => fromChannel(fromEffect$1(map$2(effect, of)));
+const fromPull = (pull) => fromChannel(fromPull$1(pull));
+const transformPull = (self, f) => fromChannel(fromTransform((_, scope) => flatMap$2(toPullScoped(self.channel, scope), (pull) => f(pull, scope))));
+const toChannel = (stream) => stream.channel;
+const callback = (f, options) => fromChannel(callbackArray(f, options));
+const empty = fromChannel(empty$1);
+const succeed = (value) => fromChannel(succeed$1(of(value)));
+const suspend = (stream) => fromChannel(suspend$1(() => stream().channel));
+const fail = (error) => fromChannel(fail$1(error));
+const die = (defect) => fromChannel(die$1(defect));
+const fromIterable = (iterable, options) => Array.isArray(iterable) && options?.chunkSize === void 0 ? fromArray(iterable) : fromChannel(fromIterableArray(iterable, options?.chunkSize));
+const fromArray = (array) => isReadonlyArrayNonEmpty(array) ? fromChannel(succeed$1(array)) : empty;
+const fromArrayEffect = (effect) => unwrap(map$2(effect, fromArray));
+const fromQueue = (queue) => fromChannel(fromQueueArray(queue));
+const fromPubSub = (pubsub) => fromChannel(fromPubSubArray(pubsub));
+const fromPubSubTake = (pubsub) => fromChannel(fromPubSubTake$1(pubsub));
+const fromReadableStream = (options) => fromChannel(fromReadableStream$1(options));
+const unwrap = (effect) => fromChannel(unwrap$1(map$2(effect, toChannel)));
+const map = dual(2, (self, f) => suspend(() => {
+	let i = 0;
+	return fromChannel(map$1(self.channel, map$3((o) => f(o, i++))));
+}));
+const mapArray = dual(2, (self, f) => fromChannel(map$1(self.channel, f)));
+const mapEffect = dual((args) => isStream(args[0]), (self, f, options) => self.channel.pipe(flattenArray, mapEffect$1(f, options), map$1(of), fromChannel));
+const mapArrayEffect = dual(2, (self, f) => fromChannel(mapEffect$1(self.channel, f)));
+const tap = dual((args) => isStream(args[0]), (self, f, options) => mapEffect(self, (a) => as(f(a), a), options));
+const flatMap = dual((args) => isStream(args[0]), (self, f, options) => self.channel.pipe(flattenArray, flatMap$1((a) => f(a).channel, options), fromChannel));
+const flatten = dual((args) => isStream(args[0]), (self, options) => flatMap(self, identity, options));
+const flattenIterable = (self) => flatMap(self, fromIterable);
+const merge = dual((args) => isStream(args[0]) && isStream(args[1]), (self, that, options) => fromChannel(merge$1(toChannel(self), toChannel(that), options)));
+const mergeAll = dual(2, (streams, options) => flatten(fromIterable(streams), options));
+const filter = dual(2, (self, predicate) => fromChannel(filterArray(toChannel(self), predicate)));
+const filterMap = dual(2, (self, filter) => fromChannel(filterMapArray(toChannel(self), filter)));
+const catch_ = dual(2, (self, f) => fromChannel(catch_$1(self.channel, (error) => f(error).channel)));
+const catchIf = dual((args) => isStream(args[0]), (self, predicate, f, orElse) => fromChannel(catchIf$1(toChannel(self), predicate, (e) => f(e).channel, orElse && ((e) => orElse(e).channel))));
+const catchFilter = dual((args) => isStream(args[0]), (self, filter, f, orElse) => fromChannel(catchFilter$1(toChannel(self), filter, (e) => f(e).channel, orElse && ((e) => orElse(e).channel))));
+const catchTags = dual((args) => isStream(args[0]), (self, cases, orElse) => {
+	let keys;
+	return catchFilter(self, (e) => {
+		keys ??= Object.keys(cases);
+		return hasProperty(e, "_tag") && isString(e["_tag"]) && keys.includes(e["_tag"]) ? succeed$5(e) : fail$4(e);
+	}, (e) => cases[e["_tag"]](e), orElse);
+});
+const catchReason = dual((args) => isStream(args[0]), (self, errorTag, reasonTag, f, orElse) => fromChannel(catchReason$1(toChannel(self), errorTag, reasonTag, (reason, error) => f(reason, error).channel, orElse && ((reason, error) => orElse(reason, error).channel))));
+const mapError = dual(2, (self, f) => fromChannel(mapError$1(self.channel, f)));
+const orDie = (self) => fromChannel(orDie$1(self.channel));
+const take = dual(2, (self, n) => {
+	const count = normalize(n);
+	return count === 0 ? empty : takeUntil(self, (_, i) => i === count - 1);
+});
+const takeUntil = dual((args) => isStream(args[0]), (self, predicate, options) => transformPull(self, (pull, _scope) => sync(() => {
+	let i = 0;
+	let done$1 = false;
+	return flatMap$2(suspend$2(() => done$1 ? done() : pull), (chunk) => {
+		const index = chunk.findIndex((a) => predicate(a, i++));
+		if (index >= 0) {
+			done$1 = true;
+			const arr = chunk.slice(0, options?.excludeLast ? index : index + 1);
+			return isReadonlyArrayNonEmpty(arr) ? succeed$2(arr) : done();
+		}
+		return succeed$2(chunk);
+	});
+})));
+const drop = dual(2, (self, n) => {
+	const count = normalize(n);
+	if (count === 0) return self;
+	return transformPull(self, (pull, _scope) => sync(() => {
+		let dropped = 0;
+		const pump = pull.pipe(flatMap$2((chunk) => {
+			if (dropped >= count) return succeed$2(chunk);
+			dropped += chunk.length;
+			if (dropped <= count) return pump;
+			return succeed$2(chunk.slice(count - dropped));
+		}));
+		return pump;
+	}));
+});
+const transduce = dual(2, (self, sink) => transformPull(self, (upstream, scope) => sync(() => {
+	let done$6;
+	let leftover;
+	const upstreamWithLeftover = suspend$2(() => {
+		if (leftover !== void 0) {
+			const chunk = leftover;
+			leftover = void 0;
+			return succeed$2(chunk);
+		}
+		return upstream;
+	}).pipe(catch_$2((error) => {
+		done$6 = fail$5(error);
+		return done();
+	}));
+	const pull = map$2(suspend$2(() => sink.transform(upstreamWithLeftover, scope)), ([value, leftover_]) => {
+		leftover = leftover_;
+		return of(value);
+	});
+	return suspend$2(() => done$6 ? done$6 : pull);
+})));
+const broadcast = dual(2, (self, options) => map$2(toPubSubTake(self, options), fromPubSubTake));
+const pipeThroughChannel = dual(2, (self, channel) => fromChannel(pipeTo(self.channel, channel)));
+const decodeText = dual((args) => isStream(args[0]), (self, options) => suspend(() => {
+	const decoder = new TextDecoder(options?.encoding);
+	return map(self, (chunk) => decoder.decode(chunk, { stream: true }));
+}));
+const splitLines = (self) => self.channel.pipe(pipeTo(splitLines$1()), fromChannel);
+const onEnd = dual(2, (self, onEnd) => fromChannel(onEnd$1(self.channel, onEnd)));
+const ensuring = dual(2, (self, finalizer) => fromChannel(ensuring$1(self.channel, finalizer)));
+const provideContext = dual(2, (self, context) => fromChannel(provideContext$1(self.channel, context)));
+const provideService = dual(3, (self, key, service) => fromChannel(provideService$1(self.channel, key, service)));
+const run = dual(2, (self, sink) => scopedWith((scope) => toPullScoped(self.channel, scope).pipe(flatMap$2((upstream) => sink.transform(upstream, scope)), map$2(([a]) => a))));
+const runCollect = (self) => runFold$1(self.channel, () => [], (acc, chunk) => {
+	for (let i = 0; i < chunk.length; i++) acc.push(chunk[i]);
+	return acc;
+});
+const runFold = dual(3, (self, initial, f) => runFold$1(self.channel, initial, (acc, arr) => {
+	for (let i = 0; i < arr.length; i++) acc = f(acc, arr[i]);
+	return acc;
+}));
+const runForEach = dual(2, (self, f) => runForEach$1(self.channel, (arr) => {
+	let i = 0;
+	return whileLoop({
+		while: () => i < arr.length,
+		body: () => f(arr[i++]),
+		step: constVoid
+	});
+}));
+const runForEachArray = dual(2, (self, f) => runForEach$1(self.channel, f));
+const runDrain = (self) => runDrain$1(self.channel);
+const mkString = (self) => runFold$1(self.channel, () => "", (acc, chunk) => acc + chunk.join(""));
+const runIntoPubSub = dual((args) => isStream(args[0]), (self, pubsub, options) => runIntoPubSubArray(self.channel, pubsub, options));
+const toPubSubTake = dual(2, (self, options) => toPubSubTake$1(self.channel, options));
+//#endregion
+export { transduce as $, mapEffect as A, interrupt as At, run as B, normalizeNonEmpty as Bt, fromPull as C, unbounded$1 as Ct, map as D, makeUnsafe$1 as Dt, isStream as E, update as Et, onEnd as F, runIn as Ft, runForEachArray as G, runDrain as H, orDie as I, camelToSnake as It, succeed as J, runIntoPubSub as K, pipeThroughChannel as L, toLowerCase as Lt, merge as M, interruptAllAs as Mt, mergeAll as N, interruptAs as Nt, mapArray as O, await_ as Ot, mkString as P, join as Pt, tap as Q, provideContext as R, parse as Rt, fromPubSub as S, unbounded as St, fromReadableStream as T, set as Tt, runFold as U, runCollect as V, runForEach as W, take as X, suspend as Y, takeUntil as Z, fromArray as _, offerAll as _t, catchTags as a, toTransform as at, fromEffect as b, poll as bt, die as c, makeUnsafe as ct, ensuring as d, endUnsafe as dt, unwrap as et, fail as f, fail$2 as ft, flattenIterable as g, offer as gt, flatMap as h, make$1 as ht, catchReason as i, pipeTo as it, mapError as j, interruptAll as jt, mapArrayEffect as k, getCurrent as kt, drop as l, bounded as lt, filterMap as m, failCauseUnsafe as mt, callback as n, map$1 as nt, catch_ as o, unwrap$1 as ot, filter as p, failCause$1 as pt, splitLines as q, catchIf as r, mapDone as rt, decodeText as s, make as st, broadcast as t, fromTransform as tt, empty as u, end as ut, fromArrayEffect as v, offerAllUnsafe as vt, fromQueue as w, make$4 as wt, fromIterable as x, take$1 as xt, fromChannel as y, offerUnsafe as yt, provideService as z, round as zt };
+
+//# sourceMappingURL=Stream-B5ebASRi.mjs.map