@akterjs/cli 0.0.0-stage → 0.1.0

package/dist/Queue-CO5UQ6os.mjs

@@ -0,0 +1,1394 @@
+import { h as fromIterable, o as empty, st as normalize } from "./Array-B4kuTQeW.mjs";
+import { $ as evaluate, B as args, F as PipeInspectableProto, K as causeFail, S as none, Sn as identity, bn as dual, ft as makePrimitive, gn as constTrue, k as Done, lt as isExit, mt as withFiber, nt as exitFailCause, rt as exitSucceed, tt as exitFail, w as some, yn as constant } from "./Option-DkxSnBhp.mjs";
+import { Fn as catchDone, Gi as sync, Hi as succeed, Ji as whileLoop, Rn as isDoneCause, Wi as suspend, bi as exitZipRight, di as andThen, fi as as, mi as callback, qi as void_, vi as exitInterrupt$1, yi as exitVoid } from "./Effect-CKFpqbmw.mjs";
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/MutableList.js
+/**
+* Mutable lists for collecting ordered values and draining them from the front.
+* A `MutableList<A>` can append values to the end, prepend values to the
+* beginning, take one or more values from the front, inspect its contents as an
+* array, filter values, remove values, and clear itself. All operations update
+* the same list object in place and keep its `length` field current. Taking
+* from an empty list returns the `Empty` symbol.
+*
+* @stability stable
+* @since 4.0.0
+*/
+/**
+* Defines the unique symbol used to represent an empty result when taking elements from a MutableList.
+* This symbol is returned by `take` when the list is empty, allowing for safe type checking.
+*
+* **When to use**
+*
+* Use to detect that `take` returned no element before handling the result as a
+* list item.
+*
+* **Example** (Checking for empty results)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<string>()
+*
+* MutableList.take(list) === MutableList.Empty // => true
+* ```
+*
+* @stability stable
+* @category symbols
+* @since 4.0.0
+*/
+const Empty = /*#__PURE__*/ Symbol.for("effect/MutableList/Empty");
+/**
+* Creates an empty MutableList.
+*
+* **Example** (Creating an empty mutable list)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<string>()
+*
+* list.length // => 0
+* MutableList.append(list, "first")
+* MutableList.take(list) // => "first"
+* list.length // => 0
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const make$1 = () => ({
+	head: void 0,
+	tail: void 0,
+	length: 0
+});
+const compactHead = (self) => {
+	const head = self.head;
+	if (head.offset >= 1024 && head === self.tail && head.mutable && (head.array.length - head.offset) * 8 <= head.offset) self.head = self.tail = {
+		array: head.array.slice(head.offset),
+		mutable: true,
+		offset: 0,
+		next: void 0
+	};
+};
+const emptyBucket = () => ({
+	array: [],
+	mutable: true,
+	offset: 0,
+	next: void 0
+});
+/**
+* Appends an element to the end of the MutableList.
+* This operation is optimized for high-frequency usage.
+*
+* **Example** (Appending elements)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<number>()
+* MutableList.append(list, 1)
+* MutableList.append(list, 2)
+* MutableList.append(list, 3)
+*
+* MutableList.toArray(list) // => [1, 2, 3]
+* list.length // => 3
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 2.0.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++;
+};
+/**
+* Appends all elements from an iterable to the end of the MutableList.
+* Returns the number of elements added. The elements are copied, so the input
+* can be reused afterward. Use `appendAllUnsafe` to transfer ownership of an
+* array instead.
+*
+* **Example** (Appending multiple elements)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<number>()
+* MutableList.append(list, 1)
+* MutableList.append(list, 2)
+*
+* MutableList.appendAll(list, [3, 4, 5]) // => 3
+* MutableList.toArray(list) // => [1, 2, 3, 4, 5]
+* list.length // => 5
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 4.0.0
+*/
+const appendAll = (self, messages) => appendAllUnsafe(self, Array.from(messages), true);
+/**
+* Appends all elements from a ReadonlyArray to the end of the MutableList.
+* This is an optimized version that can reuse the array when mutable=true.
+* Returns the number of elements added.
+*
+* **When to use**
+*
+* Use when appending a trusted array directly is worth the optimized path and
+* you can transfer ownership of the input when enabling mutation.
+*
+* **Gotchas**
+*
+* When mutable=true, ownership of the input array transfers to the list. Do not
+* read or modify the array afterward.
+*
+* **Example** (Transferring an array when appending)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<number>()
+* MutableList.append(list, 1)
+* const items = [2, 3, 4]
+* MutableList.appendAllUnsafe(list, items, true) // => 3
+*
+* MutableList.toArray(list) // => [1, 2, 3, 4]
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 4.0.0
+*/
+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;
+};
+/**
+* Removes all elements from the MutableList, resetting it to an empty state.
+* This operation is highly optimized and releases all internal memory.
+*
+* **Example** (Clearing a mutable list)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<number>()
+* MutableList.appendAll(list, [1, 2, 3, 4, 5])
+*
+* MutableList.clear(list)
+*
+* MutableList.toArray(list) // => []
+* list.length // => 0
+* MutableList.take(list) === MutableList.Empty // => true
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 4.0.0
+*/
+const clear = (self) => {
+	self.head = self.tail = void 0;
+	self.length = 0;
+};
+/**
+* Takes up to N elements from the beginning of the MutableList and returns them as an array.
+* The taken elements are removed from the list. This operation is optimized for performance
+* and includes zero-copy optimizations when possible.
+*
+* **Details**
+*
+* Finite fractional values of `n` are rounded down. `NaN` and non-positive
+* values leave the list unchanged and return an empty array.
+*
+* **Example** (Taking batches)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<number>()
+* MutableList.appendAll(list, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+*
+* MutableList.takeN(list, 3) // => [1, 2, 3]
+* MutableList.toArray(list) // => [4, 5, 6, 7, 8, 9, 10]
+* list.length // => 7
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 4.0.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.offset === chunk.array.length && chunk.next ? chunk.next : chunk;
+				self.length -= n;
+				if (self.length === 0) clear(self);
+				else compactHead(self);
+				return array;
+			}
+		}
+		chunk = chunk.next;
+	}
+	clear(self);
+	return array;
+};
+/**
+* Takes a single element from the beginning of the MutableList.
+* Returns the element if available, or the Empty symbol if the list is empty.
+* The taken element is removed from the list.
+*
+* **Example** (Taking one element)
+*
+* ```ts import.meta.vitest
+* import { MutableList } from "effect"
+*
+* const list = MutableList.make<string>()
+* MutableList.appendAll(list, ["first", "second", "third"])
+*
+* MutableList.take(list) // => "first"
+* MutableList.toArray(list) // => ["second", "third"]
+* list.length // => 2
+* ```
+*
+* @stability stable
+* @category mutations
+* @since 4.0.0
+*/
+const take$1 = (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);
+	} else compactHead(self);
+	return message;
+};
+// ../../node_modules/.pnpm/effect@4.1.2_patch_hash=0e61176203bb1256381ce1c5b488d7951983ce38ff698647d3f4617383abbf07/node_modules/effect/dist/Queue.js
+/**
+* Passes values asynchronously between fibers.
+*
+* A `Queue<A, E>` accepts values, hands each value to one consumer in offer
+* order, and can complete, fail, interrupt, or shut down. Queues can be bounded
+* or unbounded, and bounded queues can suspend, drop, or slide values when
+* producers are faster than consumers.
+*
+* @stability stable
+* @since 3.8.0
+*/
+const TypeId = "~effect/Queue";
+const EnqueueTypeId = "~effect/Queue/Enqueue";
+const DequeueTypeId = "~effect/Queue/Dequeue";
+const variance = {
+	_A: identity,
+	_E: identity
+};
+const QueueProto = {
+	[TypeId]: variance,
+	[EnqueueTypeId]: variance,
+	[DequeueTypeId]: variance,
+	...PipeInspectableProto,
+	toJSON() {
+		return {
+			_id: "effect/Queue",
+			state: this.state._tag,
+			size: sizeUnsafe(this)
+		};
+	}
+};
+/**
+* Creates a `Queue` with optional capacity and overflow strategy.
+*
+* **Details**
+*
+* By default the queue is unbounded and uses the `"suspend"` strategy. Provide
+* `capacity` for a bounded queue and choose `"suspend"`, `"dropping"`, or
+* `"sliding"` to control what happens when the queue is full. The returned
+* queue can be offered to, taken from, failed, ended, interrupted, or shut down.
+*
+* **Example** (Creating queues)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.make<number, string | Cause.Done>()
+*
+*   // add messages to the queue
+*   yield* Queue.offer(queue, 1)
+*   yield* Queue.offer(queue, 2)
+*   yield* Queue.offerAll(queue, [3, 4, 5])
+*
+*   // take messages from the queue
+*   const messages = yield* Queue.takeAll(queue)
+*
+*   // signal that the queue is done
+*   yield* Queue.end(queue)
+*   const done = yield* Effect.flip(Queue.take(queue))
+*
+*   // signal that another queue has failed
+*   const failedQueue = yield* Queue.make<number, string>()
+*   const failed = yield* Queue.fail(failedQueue, "boom")
+*   return { messages, done, failed }
+* })
+*
+* await Effect.runPromise(program) // => { messages: [1, 2, 3, 4, 5], done: Cause.Done(), failed: true }
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const make = (options) => withFiber((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$1();
+	self.scheduleRunning = false;
+	self.state = {
+		_tag: "Open",
+		takers: /* @__PURE__ */ new Set(),
+		offers: /* @__PURE__ */ new Set(),
+		awaiters: /* @__PURE__ */ new Set()
+	};
+	return succeed(self);
+});
+/**
+* Creates a bounded queue with the specified capacity that uses backpressure strategy.
+*
+* **Details**
+*
+* When the queue reaches capacity, producers will be suspended until space becomes available.
+* This ensures all messages are processed but may slow down producers.
+*
+* **Example** (Creating bounded queues)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<string>(5)
+*
+*   // This will succeed as queue has capacity
+*   yield* Queue.offer(queue, "first")
+*   yield* Queue.offer(queue, "second")
+*
+*   const size = yield* Queue.size(queue)
+*   return size
+* })
+*
+* await Effect.runPromise(program) // => 2
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const bounded = (capacity) => make({ capacity });
+/**
+* Creates a bounded queue with sliding strategy. When the queue reaches capacity,
+* new elements are added and the oldest elements are dropped.
+*
+* **When to use**
+*
+* Use when you need producer offers not to block and can accept dropping the
+* oldest messages, such as when maintaining a rolling window of recent values.
+*
+* **Example** (Creating sliding queues)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.sliding<number>(3)
+*
+*   // Fill the queue to capacity
+*   yield* Queue.offer(queue, 1)
+*   yield* Queue.offer(queue, 2)
+*   yield* Queue.offer(queue, 3)
+*
+*   // This will succeed, dropping the oldest element (1)
+*   yield* Queue.offer(queue, 4)
+*
+*   const all = yield* Queue.takeAll(queue)
+*   return all
+* })
+*
+* await Effect.runPromise(program) // => [2, 3, 4]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const sliding = (capacity) => make({
+	capacity,
+	strategy: "sliding"
+});
+/**
+* Creates an unbounded queue that can grow to any size without blocking producers.
+*
+* **When to use**
+*
+* Use when you need producers to add messages without backpressure and accept
+* unbounded memory growth.
+*
+* **Example** (Creating unbounded queues)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.unbounded<string>()
+*
+*   // Producers can always add messages without blocking
+*   yield* Queue.offer(queue, "message1")
+*   yield* Queue.offer(queue, "message2")
+*   yield* Queue.offerAll(queue, ["message3", "message4", "message5"])
+*
+*   // Check current size
+*   const size = yield* Queue.size(queue)
+*
+*   // Take all messages
+*   const messages = yield* Queue.takeAll(queue)
+*   return { size, messages }
+* })
+*
+* await Effect.runPromise(program) // => { size: 5, messages: ["message1", "message2", "message3", "message4", "message5"] }
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const unbounded = () => make();
+/**
+* Adds a message to the queue. Returns `false` if the queue is done.
+*
+* **Details**
+*
+* For bounded queues, this operation may suspend if the queue is at capacity,
+* depending on the backpressure strategy. For dropping/sliding queues, it may
+* return false or succeed immediately by dropping/sliding existing messages.
+*
+* **Example** (Offering a value)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number>(3)
+*
+*   // Successfully add messages to queue
+*   const success1 = yield* Queue.offer(queue, 1)
+*   const success2 = yield* Queue.offer(queue, 2)
+*
+*   // Queue state
+*   const size = yield* Queue.size(queue)
+*   return { offered: [success1, success2], size }
+* })
+*
+* await Effect.runPromise(program) // => { offered: [true, true], size: 2 }
+* ```
+*
+* @stability stable
+* @category offering
+* @since 2.0.0
+*/
+const offer = /*#__PURE__*/ dual(2, (self, message) => suspend(() => offerUnsafe(self, message) ? exitTrue : self.state._tag === "Open" && self.strategy === "suspend" ? offerOrWait(self, message) : exitFalse));
+/**
+* Adds a message to the queue synchronously. Returns `false` without adding the
+* message if the queue is closing or done, or if it is full with a non-sliding
+* strategy (`"suspend"` or `"dropping"`). A queue with non-positive capacity can
+* still accept a message when a taker is waiting.
+*
+* **When to use**
+*
+* Use when you are already in synchronous queue internals or a performance
+* boundary where wrapping the mutation in `Effect` is intentionally avoided.
+*
+* **Gotchas**
+*
+* This is an unsafe operation that directly modifies the queue without Effect wrapping.
+* Use this only when you're certain about the synchronous nature of the operation.
+*
+* **Example** (Offering a value synchronously)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue } from "effect"
+*
+* // Create a queue effect and extract the queue for unsafe operations
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number>(3)
+*
+*   // Add messages synchronously using unsafe API
+*   const success1 = Queue.offerUnsafe(queue, 1)
+*   const success2 = Queue.offerUnsafe(queue, 2)
+*
+*   // Check current size
+*   const size = Queue.sizeUnsafe(queue)
+*   return { offered: [success1, success2], size }
+* })
+*
+* await Effect.runPromise(program) // => { offered: [true, true], size: 2 }
+* ```
+*
+* @stability stable
+* @category offering
+* @since 4.0.0
+*/
+const offerUnsafe = (self, message) => {
+	if (self.state._tag !== "Open") return false;
+	else if (self.messages.length >= self.capacity) {
+		if (self.strategy === "sliding") {
+			take$1(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;
+};
+/**
+* Adds multiple messages to the queue. Returns the remaining messages that
+* were not added.
+*
+* **When to use**
+*
+* Use when producers can submit a batch at once and need to know which messages
+* did not fit under the queue's capacity strategy.
+*
+* **Details**
+*
+* For bounded queues, this operation may suspend if the queue doesn't have
+* enough capacity. The operation returns an array of messages that couldn't
+* be added (empty array means all messages were successfully added).
+*
+* **Example** (Offering multiple values)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.dropping<number>(3)
+*
+*   // Try to add more messages than capacity without suspending
+*   const remaining1 = yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])
+*   return remaining1
+* })
+*
+* await Effect.runPromise(program) // => [4, 5]
+* ```
+*
+* @stability stable
+* @category offering
+* @since 2.0.0
+*/
+const offerAll = /*#__PURE__*/ dual(2, (self, messages) => callback((resume) => {
+	const remaining = offerAllUnsafe(self, messages);
+	if (remaining.length === 0 || self.strategy === "dropping") return resume(exitSucceed(remaining));
+	return waitToOffer(self, {
+		_tag: "Array",
+		remaining,
+		offset: 0,
+		resume
+	});
+}));
+/**
+* Adds multiple messages to the queue synchronously. Returns the remaining messages that
+* were not added.
+*
+* **When to use**
+*
+* Use when queue internals or a performance boundary need a synchronous batch
+* offer and can handle any messages that do not fit.
+*
+* **Gotchas**
+*
+* This is an unsafe operation that directly modifies the queue without Effect wrapping.
+*
+* **Example** (Offering multiple values synchronously)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue } from "effect"
+*
+* // Create a bounded queue and use unsafe API
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number>(3)
+*
+*   // Try to add 5 messages to capacity-3 queue using unsafe API
+*   const remaining = Queue.offerAllUnsafe(queue, [1, 2, 3, 4, 5])
+*
+*   // Check what's in the queue
+*   const size = Queue.sizeUnsafe(queue)
+*   return { remaining, size }
+* })
+*
+* await Effect.runPromise(program) // => { remaining: [4, 5], size: 3 }
+* ```
+*
+* @stability stable
+* @category offering
+* @since 4.0.0
+*/
+const offerAllUnsafe = (self, messages) => {
+	if (self.state._tag !== "Open") return fromIterable(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(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;
+};
+/**
+* Fails the queue with an error. If the queue is already done, `false` is
+* returned.
+*
+* **Example** (Failing queues with an error)
+*
+* ```ts import.meta.vitest
+* import { Effect, Exit, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, string>(10)
+*
+*   // Fail the queue with an error
+*   const failed = yield* Queue.fail(queue, "Something went wrong")
+*
+*   // Taking from the failed queue fails with the error
+*   const exit = yield* Effect.exit(Queue.take(queue))
+*   return [failed, exit]
+* })
+*
+* await Effect.runPromise(program) // => [true, Exit.fail("Something went wrong")]
+* ```
+*
+* @stability stable
+* @category completion
+* @since 4.0.0
+*/
+const fail = /*#__PURE__*/ dual(2, (self, error) => failCause(self, causeFail(error)));
+/**
+* Fails the queue with a cause. If the queue is already done, `false` is
+* returned.
+*
+* **Example** (Failing queues with a cause)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Exit, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, string>(10)
+*
+*   // Create a cause and fail the queue
+*   const cause = Cause.fail("Queue processing failed")
+*   const failed = yield* Queue.failCause(queue, cause)
+*
+*   // The queue is now done with the specified failure cause
+*   const exit = yield* Effect.exit(Queue.take(queue))
+*   return [failed, exit]
+* })
+*
+* await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Queue processing failed"))]
+* ```
+*
+* @stability stable
+* @category completion
+* @since 4.0.0
+*/
+const failCause = /*#__PURE__*/ dual(2, (self, cause) => sync(() => failCauseUnsafe(self, cause)));
+/**
+* Fails the queue with a cause synchronously. If the queue is already done, `false` is
+* returned.
+*
+* **When to use**
+*
+* Use when queue completion must be driven from synchronous internals while
+* preserving the full failure `Cause`.
+*
+* **Gotchas**
+*
+* This is an unsafe operation that directly modifies the queue without Effect wrapping.
+*
+* **Example** (Failing queues with a cause synchronously)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Exit, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, string>(10)
+*
+*   // Create a cause and fail the queue synchronously
+*   const cause = Cause.fail("Processing error")
+*   const failed = Queue.failCauseUnsafe(queue, cause)
+*
+*   // The queue is now done with the specified failure cause
+*   const exit = Queue.takeUnsafe(queue)
+*   return [failed, exit]
+* })
+*
+* await Effect.runPromise(program) // => [true, Exit.failCause(Cause.fail("Processing error"))]
+* ```
+*
+* @stability stable
+* @category completion
+* @since 4.0.0
+*/
+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
+	};
+	scheduleReleaseTaker(self);
+	return true;
+};
+/**
+* Signals queue completion.
+*
+* **When to use**
+*
+* Use to stop accepting new offers while allowing already queued messages to be
+* consumed.
+*
+* **Details**
+*
+* Returns `false` if the queue is already done.
+*
+* **Example** (Ending queues)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, Cause.Done>(10)
+*
+*   // Add some messages
+*   yield* Queue.offer(queue, 1)
+*   yield* Queue.offer(queue, 2)
+*
+*   // Signal completion - no more messages will be accepted
+*   const ended = yield* Queue.end(queue)
+*
+*   // Trying to offer more messages will return false
+*   const offerResult = yield* Queue.offer(queue, 3)
+*
+*   // But we can still take existing messages
+*   const message = yield* Queue.take(queue)
+*   return [ended, offerResult, message]
+* })
+*
+* await Effect.runPromise(program) // => [true, false, 1]
+* ```
+*
+* @stability stable
+* @category completion
+* @since 4.0.0
+*/
+const end = (self) => failCause(self, causeFail(Done()));
+/**
+* Signals queue completion synchronously.
+*
+* **When to use**
+*
+* Use when implementing low-level queue integrations that must complete a queue
+* without wrapping the operation in `Effect`.
+*
+* **Details**
+*
+* Returns `false` if the queue is already done.
+*
+* **Gotchas**
+*
+* This is an unsafe operation that directly modifies the queue without Effect wrapping.
+*
+* **Example** (Ending queues synchronously)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Queue } from "effect"
+*
+* // Create a queue and use unsafe operations
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, Cause.Done>(10)
+*
+*   // Add some messages
+*   Queue.offerUnsafe(queue, 1)
+*   Queue.offerUnsafe(queue, 2)
+*
+*   // End the queue synchronously
+*   const ended = Queue.endUnsafe(queue)
+*
+*   // Existing messages can still be consumed while the queue is closing
+*   const states = [queue.state._tag]
+*
+*   Queue.takeUnsafe(queue)
+*   Queue.takeUnsafe(queue)
+*
+*   // After buffered messages are consumed, the queue is done
+*   states.push(queue.state._tag)
+*   return { ended, states }
+* })
+*
+* await Effect.runPromise(program) // => { ended: true, states: ["Closing", "Done"] }
+* ```
+*
+* @stability stable
+* @category completion
+* @since 4.0.0
+*/
+const endUnsafe = (self) => failCauseUnsafe(self, causeFail(Done()));
+/**
+* Shuts down the queue immediately, discarding buffered messages and resuming
+* pending operations.
+*
+* **Details**
+*
+* Returns `true` when the queue is shut down by this call, or `false` when it
+* has already been shut down or completed.
+*
+* **Example** (Shutting down queues)
+*
+* ```ts import.meta.vitest
+* import { Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number>(2)
+*
+*   // Add messages
+*   yield* Queue.offer(queue, 1)
+*   yield* Queue.offer(queue, 2)
+*
+*   // Shutdown clears buffered messages and prevents further offers
+*   const wasShutdown = yield* Queue.shutdown(queue)
+*
+*   // Queue is now done and cleared
+*   const size = yield* Queue.size(queue)
+*   return { wasShutdown, size }
+* })
+*
+* await Effect.runPromise(program) // => { wasShutdown: true, size: 0 }
+* ```
+*
+* @see {@link shutdownUnsafe} for synchronous shutdown
+* @stability stable
+* @category completion
+* @since 2.0.0
+*/
+const shutdown = (self) => sync(() => shutdownUnsafe(self));
+/**
+* Shuts down the queue synchronously, discarding buffered messages and resuming
+* pending operations.
+*
+* **When to use**
+*
+* Use when a synchronous callback must discard buffered messages and settle
+* pending queue operations before returning.
+*
+* **Details**
+*
+* An open queue completes with an interruption. A queue already closing retains
+* its completion cause. Call `failCauseUnsafe` first to shut down with a specific
+* failure. Returns `true` when the queue is shut down by this call, or `false`
+* when it has already been shut down or completed.
+*
+* @see {@link shutdown} for the effectful variant
+* @see {@link failCauseUnsafe} to set a failure before discarding buffered messages
+* @stability stable
+* @category completion
+* @since 4.0.0
+*/
+const shutdownUnsafe = (self) => {
+	if (self.state._tag === "Done") return false;
+	clear(self.messages);
+	const offers = self.state.offers;
+	finalize(self, self.state._tag === "Open" ? exitInterrupt : self.state.exit);
+	for (const entry of offers) resumeUnoffered(entry);
+	return true;
+};
+/**
+* Takes all currently available messages, waiting until at least one message
+* is available when the queue is empty.
+*
+* **When to use**
+*
+* Use when consumers should process the next non-empty batch of buffered
+* messages instead of repeatedly taking one message at a time.
+*
+* **Details**
+*
+* Returns a non-empty array. If the queue completes or fails before a message
+* can be taken, the effect fails with the queue's terminal error.
+*
+* **Example** (Taking all available values)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, Cause.Done>(5)
+*
+*   // Add several messages
+*   yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])
+*
+*   // Take all available messages
+*   const messages1 = yield* Queue.takeAll(queue)
+*   return messages1
+* })
+*
+* await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
+* ```
+*
+* @stability stable
+* @category taking
+* @since 2.0.0
+*/
+const takeAll = (self) => takeBetween(self, 1, Number.POSITIVE_INFINITY);
+/**
+* Takes all messages from the queue, until the queue has errored or is done.
+*
+* **Example** (Collecting values until completion)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, Cause.Done>(5)
+*
+*   // Add several messages
+*   yield* Queue.offerAll(queue, [1, 2, 3, 4, 5])
+*   yield* Queue.end(queue)
+*
+*   // Collect all available messages
+*   return yield* Queue.collect(queue)
+* })
+*
+* await Effect.runPromise(program) // => [1, 2, 3, 4, 5]
+* ```
+*
+* @stability stable
+* @category taking
+* @since 4.0.0
+*/
+const collect = (self) => suspend(() => {
+	const out = empty();
+	return as(catchDone(whileLoop({
+		while: constTrue,
+		body: constant(takeAll(self)),
+		step(items) {
+			for (let i = 0; i < items.length; i++) out.push(items[i]);
+		}
+	}), () => void_), out);
+});
+/**
+* Takes between `min` and `max` messages from the queue.
+*
+* **Details**
+*
+* The operation waits when fewer than the required minimum messages are
+* available. It returns at most `max` messages. Finite fractional bounds are
+* rounded down, while `NaN` and non-positive bounds are treated as `0`. If the
+* queue is closing, drains the currently available messages even when fewer
+* than `min` are available. Once the queue is done, the effect fails with the
+* queue's terminal error.
+*
+* **Example** (Taking a bounded batch of values)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number>(10)
+*
+*   // Add several messages
+*   yield* Queue.offerAll(queue, [1, 2, 3, 4, 5, 6, 7, 8])
+*
+*   // Take between 2 and 5 messages
+*   const batch1 = yield* Queue.takeBetween(queue, 2, 5)
+*
+*   // Take between 1 and 10 messages (but only 3 remain)
+*   const batch2 = yield* Queue.takeBetween(queue, 1, 10)
+*
+*   // No more messages available, will wait or return done
+*   // const batch3 = yield* Queue.takeBetween(queue, 1, 3)
+*   return [batch1, batch2]
+* })
+*
+* await Effect.runPromise(program) // => [[1, 2, 3, 4, 5], [6, 7, 8]]
+* ```
+*
+* @stability stable
+* @category taking
+* @since 2.0.0
+*/
+const takeBetween = /*#__PURE__*/ dual(3, (self, min, max) => {
+	min = normalize(min);
+	max = normalize(max);
+	return suspendTake(() => takeBetweenUnsafe(self, min, max) ?? andThen(awaitTake(self, () => canTake(self, min)), takeBetween(self, min, max)));
+});
+/**
+* Takes a single message from the queue, or wait for a message to be
+* available.
+*
+* **Details**
+*
+* If the queue is done, it will fail with `Done`. If the
+* queue fails, the Effect will fail with the error.
+*
+* **Example** (Taking one value)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Exit, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<string, Cause.Done>(3)
+*
+*   // Add some messages
+*   yield* Queue.offer(queue, "first")
+*   yield* Queue.offer(queue, "second")
+*
+*   // Take messages one by one
+*   const msg1 = yield* Queue.take(queue)
+*   const msg2 = yield* Queue.take(queue)
+*
+*   // End the queue
+*   yield* Queue.end(queue)
+*
+*   // Taking from an ended queue fails with Done
+*   const result = yield* Effect.exit(Queue.take(queue))
+*   return [[msg1, msg2], result]
+* })
+*
+* await Effect.runPromise(program) // => [["first", "second"], Exit.fail(Cause.Done())]
+* ```
+*
+* @stability stable
+* @category taking
+* @since 2.0.0
+*/
+const take = (self) => suspendTake(() => takeUnsafe(self) ?? andThen(awaitTake(self, () => canTake(self, 1)), take(self)));
+/**
+* Attempts to take one item from the queue without waiting.
+*
+* **Details**
+*
+* Returns `Option.some` when an item is immediately available. Returns
+* `Option.none` when no item is available, when the queue is done, or when the
+* immediate take observes a queue failure.
+*
+* **Example** (Polling without blocking)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number>(10)
+*
+*   // Poll returns Option.none if empty
+*   const maybe1 = yield* Queue.poll(queue)
+*
+*   // Add an item
+*   yield* Queue.offer(queue, 42)
+*
+*   // Poll returns Option.some with the item
+*   const maybe2 = yield* Queue.poll(queue)
+*   return [maybe1, maybe2]
+* })
+*
+* await Effect.runPromise(program) // => [Option.none(), Option.some(42)]
+* ```
+*
+* @stability stable
+* @category taking
+* @since 2.0.0
+*/
+const poll = (self) => suspendTake(() => {
+	const result = takeUnsafe(self);
+	if (result === void 0) return succeed(none());
+	if (result._tag === "Success") return succeed(some(result.value));
+	return succeed(none());
+});
+/**
+* Attempts to take one message from the queue synchronously.
+*
+* **When to use**
+*
+* Use when polling queue internals must not suspend or register a waiting taker,
+* and `undefined` is an acceptable result for an empty queue.
+*
+* **Details**
+*
+* Returns an `Exit` for an immediately available message or for the queue's
+* terminal state. Returns `undefined` when no message is immediately available.
+* This operation does not wait or register a taker.
+*
+* **Example** (Taking one value synchronously)
+*
+* ```ts import.meta.vitest
+* import { Effect, Exit, Queue } from "effect"
+*
+* // Create a queue and use unsafe operations
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number>(10)
+*
+*   // Add some messages
+*   Queue.offerUnsafe(queue, 1)
+*   Queue.offerUnsafe(queue, 2)
+*
+*   // Take a message synchronously
+*   const result1 = Queue.takeUnsafe(queue)
+*
+*   const result2 = Queue.takeUnsafe(queue)
+*
+*   // No more messages - returns undefined
+*   const result3 = Queue.takeUnsafe(queue)
+*   return [result1, result2, result3]
+* })
+*
+* await Effect.runPromise(program) // => [Exit.succeed(1), Exit.succeed(2), undefined]
+* ```
+*
+* @stability stable
+* @category taking
+* @since 4.0.0
+*/
+const takeUnsafe = (self) => {
+	if (self.state._tag === "Done") return self.state.exit;
+	if (self.messages.length > 0) {
+		const message = take$1(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);
+	}
+};
+/**
+* Returns the current number of buffered messages in the queue synchronously.
+*
+* **When to use**
+*
+* Use when you need an immediate `Queue` size snapshot for diagnostics or
+* internals and do not need the read wrapped in `Effect`.
+*
+* **Details**
+*
+* After `endUnsafe`, a queue remains `Closing` while buffered messages are
+* drained, and its size continues to include those messages. A `Done` queue
+* reports a size of `0`. This unsafe operation reads the queue state directly
+* without Effect wrapping.
+*
+* **Example** (Checking queue size synchronously)
+*
+* ```ts import.meta.vitest
+* import { Cause, Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.bounded<number, Cause.Done>(10)
+*
+*   // Check size of empty queue
+*   const size1 = Queue.sizeUnsafe(queue)
+*
+*   // Add some messages
+*   Queue.offerUnsafe(queue, 1)
+*   Queue.offerUnsafe(queue, 2)
+*   Queue.offerUnsafe(queue, 3)
+*
+*   // Check size after adding messages
+*   const size2 = Queue.sizeUnsafe(queue)
+*
+*   // End the queue
+*   Queue.endUnsafe(queue)
+*
+*   // Ending retains the buffered size while the queue is Closing
+*   const size3 = Queue.sizeUnsafe(queue)
+*   return [size1, size2, size3]
+* })
+*
+* await Effect.runPromise(program) // => [0, 3, 3]
+* ```
+*
+* @stability stable
+* @category sizes
+* @since 4.0.0
+*/
+const sizeUnsafe = (self) => self.state._tag === "Done" ? 0 : self.messages.length;
+const exitFalse = /*#__PURE__*/ exitSucceed(false);
+const exitTrue = /*#__PURE__*/ exitSucceed(true);
+const exitFailDone = /*#__PURE__*/ exitFail(/*#__PURE__*/ Done());
+const exitInterrupt = /*#__PURE__*/ exitInterrupt$1();
+const releaseTakers = (self) => {
+	if (self.state._tag === "Done" || self.state.takers.size === 0) return;
+	for (const taker of self.state.takers) {
+		if (!taker.ready()) continue;
+		self.state.takers.delete(taker);
+		taker.resume(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 (!canTake(self, min)) return;
+	const messages = self.messages.length > 0 ? takeN(self.messages, max) : [takeOfferUnsafe(self.state.offers)];
+	releaseCapacity(self);
+	return exitSucceed(messages);
+};
+const suspendTake = /*#__PURE__*/ makePrimitive({
+	op: "QueueTake",
+	[evaluate](fiber) {
+		const effect = this[args]();
+		return isExit(effect) ? effect[evaluate](fiber) : effect;
+	}
+});
+const canTake = (self, min) => self.messages.length >= (self.state._tag === "Closing" ? 1 : Math.min(min, self.capacity || 1)) || self.capacity <= 0 && self.state._tag !== "Done" && self.state.offers.size > 0;
+const awaitTake = (self, ready) => callback((resume) => {
+	if (self.state._tag === "Done") return resume(self.state.exit);
+	if (ready()) return resume(exitVoid);
+	const taker = {
+		ready,
+		resume
+	};
+	self.state.takers.add(taker);
+	return sync(() => {
+		if (self.state._tag !== "Done") self.state.takers.delete(taker);
+	});
+});
+const offerOrWait = (self, message) => callback((resume) => offerUnsafe(self, message) ? resume(exitTrue) : waitToOffer(self, {
+	_tag: "Single",
+	message,
+	resume
+}));
+const waitToOffer = (self, entry) => {
+	if (self.state._tag !== "Open") return resumeUnoffered(entry);
+	const offers = self.state.offers;
+	offers.add(entry);
+	return sync(() => {
+		if (self.state._tag === "Done") return;
+		offers.delete(entry);
+		if (self.state._tag === "Closing" && offers.size === 0 && self.messages.length === 0) finalize(self, self.state.exit);
+	});
+};
+const resumeUnoffered = (entry) => entry._tag === "Single" ? entry.resume(exitFalse) : entry.resume(exitSucceed(entry.remaining.slice(entry.offset)));
+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([]));
+		}
+		const state = self.state;
+		if (state._tag === "Done") return isDoneCause(state.exit.cause);
+	}
+	return false;
+};
+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.resume(exit);
+	openState.takers.clear();
+	for (const awaiter of openState.awaiters) awaiter(exit);
+	openState.awaiters.clear();
+};
+export { takeAll as _, fail as a, make as c, offerUnsafe as d, poll as f, take as g, sliding as h, endUnsafe as i, offer as l, shutdownUnsafe as m, collect as n, failCause as o, shutdown as p, end as r, failCauseUnsafe as s, bounded as t, offerAll as u, unbounded as v };