@deslop/workbench 0.0.344 → 0.0.352

package/dist/server.js

@@ -21,8 +21,6 @@ import * as NodeStreamP from "node:stream/promises";
 import { pipeline } from "node:stream/promises";
 import * as readline from "node:readline";
 import * as nodePty from "@lydell/node-pty";
-import SerializeModule from "@xterm/addon-serialize";
-import HeadlessModule from "@xterm/headless";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -6386,7 +6384,7 @@ const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
 * @category getters
 * @since 2.0.0
 */
-const get$10 = /*#__PURE__*/ dual(2, (self, index) => {
+const get$9 = /*#__PURE__*/ dual(2, (self, index) => {
 	const i = Math.floor(index);
 	return isOutOfBounds(i, self) ? none() : some(self[i]);
 });
@@ -6445,7 +6443,7 @@ const getUnsafe$1 = /*#__PURE__*/ dual(2, (self, index) => {
 * @category getters
 * @since 2.0.0
 */
-const head = /*#__PURE__*/ get$10(0);
+const head = /*#__PURE__*/ get$9(0);
 /**
 * Returns the first element of a `NonEmptyReadonlyArray` directly (no `Option`
 * wrapper).
@@ -7200,7 +7198,7 @@ const ServiceProto = {
 	.../*#__PURE__*/ Prototype({
 		label: "Service",
 		evaluate(fiber) {
-			return exitSucceed(get$9(fiber.context, this));
+			return exitSucceed(get$8(fiber.context, this));
 		}
 	}),
 	toJSON() {
@@ -7217,10 +7215,10 @@ const ServiceProto = {
 		return make$62(this, self);
 	},
 	use(f) {
-		return withFiber$1((fiber) => f(get$9(fiber.context, this)));
+		return withFiber$1((fiber) => f(get$8(fiber.context, this)));
 	},
 	useSync(f) {
-		return withFiber$1((fiber) => exitSucceed(f(get$9(fiber.context, this))));
+		return withFiber$1((fiber) => exitSucceed(f(get$8(fiber.context, this))));
 	}
 };
 const ReferenceTypeId = "~effect/Context/Reference";
@@ -7559,7 +7557,7 @@ const getUnsafe = /*#__PURE__*/ dual(2, (self, service) => {
 * @category getters
 * @since 2.0.0
 */
-const get$9 = getUnsafe;
+const get$8 = getUnsafe;
 /**
 * Gets the value for a `Context.Reference`, returning its cached default when
 * the context does not contain an override.
@@ -10107,7 +10105,7 @@ const scope$1 = scopeTag;
 /** @internal */
 const provideScope = /*#__PURE__*/ provideService$1(scopeTag);
 /** @internal */
-const scoped$4 = (self) => withFiber$1((fiber) => {
+const scoped$2 = (self) => withFiber$1((fiber) => {
 	const prev = fiber.context;
 	const scope = scopeMakeUnsafe();
 	fiber.setContext(add(fiber.context, scopeTag, scope));
@@ -10597,11 +10595,11 @@ const NoopSpanProto = {
 const noopSpan = (options) => Object.assign(Object.create(NoopSpanProto), options);
 const filterDisablePropagation = (span) => {
 	if (!span) return none();
-	return get$9(span.annotations, DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(getOrUndefined$1(span.parent)) : none() : some(span);
+	return get$8(span.annotations, DisablePropagation) ? span._tag === "Span" ? filterDisablePropagation(getOrUndefined$1(span.parent)) : none() : some(span);
 };
 /** @internal */
 const makeSpanUnsafe = (fiber, name, options) => {
-	const disablePropagation = !fiber.getRef(TracerEnabled$1) || options?.annotations && get$9(options.annotations, DisablePropagation);
+	const disablePropagation = !fiber.getRef(TracerEnabled$1) || options?.annotations && get$8(options.annotations, DisablePropagation);
 	const parent = options?.parent !== void 0 ? some(options.parent) : options?.root ? none() : filterDisablePropagation(fiber.currentSpan);
 	let span;
 	if (disablePropagation) span = noopSpan({
@@ -12521,7 +12519,7 @@ const effectDiscard = (effect) => effectContext(as$1(effect, empty$12()));
 */
 const unwrap$4 = (self) => {
 	const service = Service("effect/Layer/unwrap");
-	return flatMap$3(effect(service)(self), get$9(service));
+	return flatMap$3(effect(service)(self), get$8(service));
 };
 const mergeAllEffect = (layers, memoMap, scope) => {
 	const parentScope = forkUnsafe(scope, "parallel");
@@ -12870,7 +12868,7 @@ const flatMap$3 = /*#__PURE__*/ dual(2, (self, f) => fromBuild((memoMap, scope)
 * @category converting
 * @since 2.0.0
 */
-const launch = (self) => scoped$4(andThen$1(build(self), never$2));
+const launch = (self) => scoped$2(andThen$1(build(self), never$2));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Cause.js
 /**
@@ -13827,30 +13825,6 @@ const toDateUtc$1 = (self) => new Date(self.epochMilliseconds);
 */
 const Number$4 = globalThis.Number;
 /**
-* Returns the next power of 2 from the given number.
-*
-* **When to use**
-*
-* Use to round a number up to the next power of two.
-*
-* **Example** (Finding the next power of two)
-*
-* ```ts
-* import { Number } from "effect"
-* import * as assert from "node:assert"
-*
-* assert.deepStrictEqual(Number.nextPow2(5), 8)
-* assert.deepStrictEqual(Number.nextPow2(17), 32)
-* ```
-*
-* @category math
-* @since 2.0.0
-*/
-const nextPow2 = (n) => {
-	const nextPow = Math.ceil(Math.log(n) / Math.log(2));
-	return Math.max(Math.pow(2, nextPow), 2);
-};
-/**
 * Parses a `number` from a `string` safely using the `Number()` function.
 * The following special string values are supported: "NaN", "Infinity", "-Infinity".
 *
@@ -14571,7 +14545,7 @@ const MetricRegistry = /*#__PURE__*/ Reference("~effect/observability/Metric/Met
 * @since 4.0.0
 */
 const snapshotUnsafe = (context) => {
-	const registry = get$9(context, MetricRegistry);
+	const registry = get$8(context, MetricRegistry);
 	return Array.from(registry.values()).map(({ hooks, ...meta }) => ({
 		...meta,
 		state: hooks.get(context)
@@ -17046,7 +17020,7 @@ const scope = scope$1;
 * @category resource management
 * @since 2.0.0
 */
-const scoped$3 = scoped$4;
+const scoped$1 = scoped$2;
 /**
 * Creates a scoped effect by providing access to the scope.
 *
@@ -23356,7 +23330,7 @@ const takeAll$2 = (self) => takeN(self, self.length);
 * @category elements
 * @since 4.0.0
 */
-const take$3 = (self) => {
+const take$2 = (self) => {
 	if (!self.head) return Empty$2;
 	const message = self.head.array[self.head.offset];
 	if (self.head.mutable) self.head.array[self.head.offset] = void 0;
@@ -23525,39 +23499,6 @@ const make$50 = (value) => {
 	return ref;
 };
 /**
-* Gets the current value of the MutableRef.
-*
-* **When to use**
-*
-* Use to read the current value without mutating the reference.
-*
-* **Example** (Reading current values)
-*
-* ```ts
-* import { MutableRef } from "effect"
-*
-* const ref = MutableRef.make("hello")
-* console.log(MutableRef.get(ref)) // "hello"
-*
-* MutableRef.set(ref, "world")
-* console.log(MutableRef.get(ref)) // "world"
-*
-* // Reading complex objects
-* const config = MutableRef.make({ port: 3000, host: "localhost" })
-* const currentConfig = MutableRef.get(config)
-* console.log(currentConfig.port) // 3000
-*
-* // Multiple reads return the same value
-* const value1 = MutableRef.get(ref)
-* const value2 = MutableRef.get(ref)
-* console.log(value1 === value2) // true
-* ```
-*
-* @category general
-* @since 2.0.0
-*/
-const get$8 = (self) => self.current;
-/**
 * Sets the MutableRef to a new value and returns the reference.
 *
 * **When to use**
@@ -23694,41 +23635,6 @@ const SubscriptionTypeId = "~effect/PubSub/Subscription";
 */
 const make$49 = (options) => sync(() => makePubSubUnsafe(options.atomicPubSub(), /* @__PURE__ */ new Map(), makeUnsafe$6(), makeUnsafe$4(false), make$50(false), options.strategy()));
 /**
-* Creates a bounded `PubSub` that applies backpressure when it reaches
-* capacity.
-*
-* **Details**
-*
-* Published messages are retained until all current subscribers have taken
-* them. When the capacity is full, publishers suspend until space is available.
-* Pass an options object to configure both `capacity` and an optional replay
-* buffer for late subscribers.
-*
-* **Example** (Creating a bounded PubSub)
-*
-* ```ts
-* import { Effect, PubSub } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   // Create bounded PubSub with capacity 100
-*   const pubsub = yield* PubSub.bounded<string>(100)
-*
-*   // Create with replay buffer for late subscribers
-*   const pubsubWithReplay = yield* PubSub.bounded<string>({
-*     capacity: 100,
-*     replay: 10 // Last 10 messages replayed to new subscribers
-*   })
-* })
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const bounded$1 = (capacity) => make$49({
-	atomicPubSub: () => makeAtomicBounded(capacity),
-	strategy: () => new BackPressureStrategy()
-});
-/**
 * Creates an unbounded `PubSub`.
 *
 * **Example** (Creating an unbounded PubSub)
@@ -23762,47 +23668,11 @@ const bounded$1 = (capacity) => make$49({
 * @category constructors
 * @since 2.0.0
 */
-const unbounded$1 = (options) => make$49({
+const unbounded = (options) => make$49({
 	atomicPubSub: () => makeAtomicUnbounded(options),
 	strategy: () => new DroppingStrategy()
 });
 /**
-* Creates a bounded atomic PubSub implementation with optional replay buffer.
-*
-* **When to use**
-*
-* Use to provide bounded message storage when building a custom `PubSub` with
-* `make` and an explicit delivery strategy.
-*
-* **Details**
-*
-* Pass either a capacity number or an options object with `capacity` and
-* optional `replay`. A positive `replay` value enables a replay buffer for late
-* subscribers, and fractional replay sizes are rounded up.
-*
-* **Gotchas**
-*
-* The capacity must be greater than zero; invalid capacities throw
-* synchronously before an atomic implementation is created.
-*
-* @see {@link make} for constructing a `PubSub` from an atomic implementation and delivery strategy
-* @see {@link makeAtomicUnbounded} for an atomic implementation without a bounded capacity
-* @see {@link bounded} for the higher-level backpressure constructor
-* @see {@link dropping} for the higher-level dropping constructor
-* @see {@link sliding} for the higher-level sliding constructor
-*
-* @category constructors
-* @since 4.0.0
-*/
-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);
-};
-/**
 * Creates an unbounded atomic PubSub implementation with optional replay buffer.
 *
 * **When to use**
@@ -23824,93 +23694,6 @@ const makeAtomicBounded = (capacity) => {
 */
 const makeAtomicUnbounded = (options) => new UnboundedPubSub(options?.replay ? new ReplayBuffer(options.replay) : void 0);
 /**
-* Shuts down the `PubSub`, interrupting suspended publishers and subscribers
-* and finalizing active subscriptions.
-*
-* **Details**
-*
-* After shutdown, `publish` and `publishAll` succeed with `false`,
-* `publishUnsafe` returns `false`, and subscription operations such as `take`
-* interrupt.
-*
-* **Example** (Shutting down a PubSub)
-*
-* ```ts
-* import { Effect, PubSub } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const pubsub = yield* PubSub.bounded<string>(1)
-*
-*   // Shutdown the PubSub
-*   yield* PubSub.shutdown(pubsub)
-*
-*   const isShutdown = yield* PubSub.isShutdown(pubsub)
-*   console.log("Is shutdown:", isShutdown) // true
-*
-*   // Publishing after shutdown returns false
-*   const published = yield* PubSub.publish(pubsub, "msg1")
-*   console.log("Published after shutdown:", published) // false
-* })
-* ```
-*
-* @category lifecycle
-* @since 2.0.0
-*/
-const shutdown$1 = (self) => uninterruptible(withFiber((fiber) => {
-	set$6(self.shutdownFlag, true);
-	return close(self.scope, interrupt$2(fiber.id)).pipe(andThen(self.strategy.shutdown), when$2(self.shutdownHook.open), asVoid);
-}));
-/**
-* Publishes a message to the `PubSub` as an `Effect`, returning whether the
-* message was accepted.
-*
-* **When to use**
-*
-* Use when publishing from effectful code and the configured PubSub strategy
-* should handle surplus messages.
-*
-* **Details**
-*
-* The effect succeeds with `false` if the `PubSub` is shut down. If the message
-* cannot be accepted immediately, the configured strategy decides how surplus
-* messages are handled.
-*
-* **Example** (Publishing a message)
-*
-* ```ts
-* import { Effect, PubSub } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const pubsub = yield* PubSub.bounded<string>(10)
-*
-*   // Publish a message
-*   const published = yield* PubSub.publish(pubsub, "Hello World")
-*   console.log("Message published:", published) // true
-*
-*   yield* Effect.scoped(Effect.gen(function*() {
-*     const subscription = yield* PubSub.subscribe(pubsub)
-*
-*     yield* PubSub.publish(pubsub, "Hello")
-*     const message = yield* PubSub.take(subscription)
-*     console.log("Received:", message) // "Hello"
-*   }))
-* })
-* ```
-*
-* @see {@link publishUnsafe} for a synchronous non-blocking attempt that does not run effectful surplus handling
-*
-* @category publishing
-* @since 2.0.0
-*/
-const publish = /*#__PURE__*/ dual(2, (self, value) => suspend$2(() => {
-	if (self.shutdownFlag.current) return succeed$3(false);
-	if (self.pubsub.publish(value)) {
-		self.strategy.completeSubscribersUnsafe(self.pubsub, self.subscribers);
-		return succeed$3(true);
-	}
-	return self.strategy.handleSurplus(self.pubsub, self.subscribers, [value], self.shutdownFlag);
-}));
-/**
 * Attempts to publish a message synchronously without applying the PubSub
 * strategy's effectful surplus handling.
 *
@@ -24009,7 +23792,7 @@ const publishUnsafe = /*#__PURE__*/ dual(2, (self, value) => {
 * @since 2.0.0
 */
 const subscribe = (self) => uninterruptible(contextWith((services) => {
-	const localScope = get$9(services, Scope);
+	const localScope = get$8(services, Scope);
 	const scope = forkUnsafe(self.scope);
 	const subscription = makeSubscriptionUnsafe(self.pubsub, self.subscribers, self.strategy);
 	return addFinalizer$1(scope, unsubscribe(subscription)).pipe(andThen(addFinalizerExit(localScope, (exit) => close(scope, exit))), as(subscription));
@@ -24026,49 +23809,6 @@ const unsubscribe = (self) => uninterruptible(withFiber((state) => {
 	})), when$2(self.shutdownHook.open), asVoid);
 }));
 /**
-* Takes a single message from the subscription. If no messages are available,
-* this will suspend until a message becomes available.
-*
-* **Example** (Taking a message)
-*
-* ```ts
-* import { Effect, Fiber, PubSub } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const pubsub = yield* PubSub.bounded<string>(10)
-*
-*   yield* Effect.scoped(Effect.gen(function*() {
-*     const subscription = yield* PubSub.subscribe(pubsub)
-*
-*     // Start a fiber to take a message (will suspend)
-*     const takeFiber = yield* Effect.forkChild(
-*       PubSub.take(subscription)
-*     )
-*
-*     // Publish a message
-*     yield* PubSub.publish(pubsub, "Hello")
-*
-*     // The take will now complete
-*     const message = yield* Fiber.join(takeFiber)
-*     console.log("Received:", message) // "Hello"
-*   }))
-* })
-* ```
-*
-* @category subscriptions
-* @since 4.0.0
-*/
-const take$2 = (self) => suspend$2(() => {
-	if (self.shutdownFlag.current) return interrupt$1;
-	if (self.replayWindow.remaining > 0) return succeed$3(self.replayWindow.take());
-	const message = self.pollers.length === 0 ? self.subscription.poll() : Empty$2;
-	if (message === Empty$2) return pollForItem(self);
-	else {
-		self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
-		return succeed$3(message);
-	}
-});
-/**
 * Takes all available messages from the subscription, suspending if no items
 * are available.
 *
@@ -24120,53 +23860,6 @@ const pollForItem = (self) => {
 		return void_$1;
 	});
 };
-/**
-* Takes up to the specified number of messages from the subscription without suspending.
-*
-* **Example** (Taking up to a maximum number of messages)
-*
-* ```ts
-* import { Effect, PubSub } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const pubsub = yield* PubSub.bounded<string>(10)
-*
-*   yield* Effect.scoped(Effect.gen(function*() {
-*     const subscription = yield* PubSub.subscribe(pubsub)
-*
-*     // Publish multiple messages
-*     yield* PubSub.publishAll(pubsub, ["msg1", "msg2", "msg3", "msg4", "msg5"])
-*
-*     // Take up to 3 messages
-*     const upTo3 = yield* PubSub.takeUpTo(subscription, 3)
-*     console.log("Up to 3:", upTo3) // ["msg1", "msg2", "msg3"]
-*
-*     // Take up to 5 more (only 2 remaining)
-*     const upTo5 = yield* PubSub.takeUpTo(subscription, 5)
-*     console.log("Up to 5:", upTo5) // ["msg4", "msg5"]
-*
-*     // No more messages available
-*     const noMore = yield* PubSub.takeUpTo(subscription, 10)
-*     console.log("No more:", noMore) // []
-*   }))
-* })
-* ```
-*
-* @category subscriptions
-* @since 4.0.0
-*/
-const takeUpTo = /*#__PURE__*/ dual(2, (self, max) => suspend$2(() => {
-	if (self.shutdownFlag.current) return interrupt$1;
-	let replay = void 0;
-	if (self.replayWindow.remaining >= max) return succeed$3(self.replayWindow.takeN(max));
-	else if (self.replayWindow.remaining > 0) {
-		replay = self.replayWindow.takeAll();
-		max = max - replay.length;
-	}
-	const as = self.pollers.length === 0 ? self.subscription.pollUpTo(max) : [];
-	self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
-	return replay ? succeed$3(replay.concat(as)) : succeed$3(as);
-}));
 const AbsentValue = /*#__PURE__*/ Symbol.for("effect/PubSub/AbsentValue");
 const addSubscribers = (subscribers, subscription, pollers) => {
 	if (!subscribers.has(subscription)) subscribers.set(subscription, /* @__PURE__ */ new Set());
@@ -24179,395 +23872,6 @@ const removeSubscribers = (subscribers, subscription, pollers) => {
 	if (set.size === 0) subscribers.delete(subscription);
 };
 const makeSubscriptionUnsafe = (pubsub, subscribers, strategy) => new SubscriptionImpl(pubsub, subscribers, pubsub.subscribe(), make$51(), makeUnsafe$4(false), make$50(false), strategy, pubsub.replayWindow());
-var BoundedPubSubArb = class {
-	array;
-	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.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;
-		if (this.subscriberCount !== 0) {
-			const index = this.publisherIndex % this.capacity;
-			this.array[index] = value;
-			this.subscribers[index] = this.subscriberCount;
-			this.publisherIndex += 1;
-		}
-		if (this.replayBuffer) this.replayBuffer.offer(value);
-		return true;
-	}
-	publishAll(elements) {
-		if (this.subscriberCount === 0) {
-			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
-			return [];
-		}
-		const chunk = fromIterable$2(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;
-			this.subscribers[index] = this.subscriberCount;
-			this.publisherIndex += 1;
-			if (this.replayBuffer) this.replayBuffer.offer(a);
-		}
-		return chunk.slice(iteratorIndex);
-	}
-	slide() {
-		if (this.subscribersIndex !== this.publisherIndex) {
-			const index = this.subscribersIndex % this.capacity;
-			this.array[index] = AbsentValue;
-			this.subscribers[index] = 0;
-			this.subscribersIndex += 1;
-		}
-		if (this.replayBuffer) this.replayBuffer.slide();
-	}
-	subscribe() {
-		this.subscriberCount += 1;
-		return new BoundedPubSubArbSubscription(this, this.publisherIndex, false);
-	}
-};
-var BoundedPubSubArbSubscription = class {
-	self;
-	subscriberIndex;
-	unsubscribed;
-	constructor(self, subscriberIndex, unsubscribed) {
-		this.self = self;
-		this.subscriberIndex = subscriberIndex;
-		this.unsubscribed = unsubscribed;
-	}
-	isEmpty() {
-		return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
-	}
-	size() {
-		if (this.unsubscribed) return 0;
-		return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
-	}
-	poll() {
-		if (this.unsubscribed) return Empty$2;
-		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
-		if (this.subscriberIndex !== this.self.publisherIndex) {
-			const index = this.subscriberIndex % this.self.capacity;
-			const elem = this.self.array[index];
-			this.self.subscribers[index] -= 1;
-			if (this.self.subscribers[index] === 0) {
-				this.self.array[index] = AbsentValue;
-				this.self.subscribersIndex += 1;
-			}
-			this.subscriberIndex += 1;
-			return elem;
-		}
-		return Empty$2;
-	}
-	pollUpTo(n) {
-		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;
-	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.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;
-		if (this.subscriberCount !== 0) {
-			const index = this.publisherIndex & this.mask;
-			this.array[index] = value;
-			this.subscribers[index] = this.subscriberCount;
-			this.publisherIndex += 1;
-		}
-		if (this.replayBuffer) this.replayBuffer.offer(value);
-		return true;
-	}
-	publishAll(elements) {
-		if (this.subscriberCount === 0) {
-			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
-			return [];
-		}
-		const chunk = fromIterable$2(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;
-			this.subscribers[index] = this.subscriberCount;
-			this.publisherIndex += 1;
-			if (this.replayBuffer) this.replayBuffer.offer(elem);
-		}
-		return chunk.slice(iteratorIndex);
-	}
-	slide() {
-		if (this.subscribersIndex !== this.publisherIndex) {
-			const index = this.subscribersIndex & this.mask;
-			this.array[index] = AbsentValue;
-			this.subscribers[index] = 0;
-			this.subscribersIndex += 1;
-		}
-		if (this.replayBuffer) this.replayBuffer.slide();
-	}
-	subscribe() {
-		this.subscriberCount += 1;
-		return new BoundedPubSubPow2Subscription(this, this.publisherIndex, false);
-	}
-};
-var BoundedPubSubPow2Subscription = class {
-	self;
-	subscriberIndex;
-	unsubscribed;
-	constructor(self, subscriberIndex, unsubscribed) {
-		this.self = self;
-		this.subscriberIndex = subscriberIndex;
-		this.unsubscribed = unsubscribed;
-	}
-	isEmpty() {
-		return this.unsubscribed || this.self.publisherIndex === this.subscriberIndex || this.self.publisherIndex === this.self.subscribersIndex;
-	}
-	size() {
-		if (this.unsubscribed) return 0;
-		return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
-	}
-	poll() {
-		if (this.unsubscribed) return Empty$2;
-		this.subscriberIndex = Math.max(this.subscriberIndex, this.self.subscribersIndex);
-		if (this.subscriberIndex !== this.self.publisherIndex) {
-			const index = this.subscriberIndex & this.self.mask;
-			const elem = this.self.array[index];
-			this.self.subscribers[index] -= 1;
-			if (this.self.subscribers[index] === 0) {
-				this.self.array[index] = AbsentValue;
-				this.self.subscribersIndex += 1;
-			}
-			this.subscriberIndex += 1;
-			return elem;
-		}
-		return Empty$2;
-	}
-	pollUpTo(n) {
-		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;
-	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;
-		if (this.subscriberCount !== 0) {
-			this.value = value;
-			this.subscribers = this.subscriberCount;
-			this.publisherIndex += 1;
-		}
-		if (this.replayBuffer) this.replayBuffer.offer(value);
-		return true;
-	}
-	publishAll(elements) {
-		if (this.subscriberCount === 0) {
-			if (this.replayBuffer) this.replayBuffer.offerAll(elements);
-			return [];
-		}
-		const chunk = fromIterable$2(elements);
-		if (chunk.length === 0) return chunk;
-		if (this.publish(chunk[0])) return chunk.slice(1);
-		else return chunk;
-	}
-	slide() {
-		if (this.isFull()) {
-			this.subscribers = 0;
-			this.value = AbsentValue;
-		}
-		if (this.replayBuffer) this.replayBuffer.slide();
-	}
-	subscribe() {
-		this.subscriberCount += 1;
-		return new BoundedPubSubSingleSubscription(this, this.publisherIndex, false);
-	}
-};
-var BoundedPubSubSingleSubscription = class {
-	self;
-	subscriberIndex;
-	unsubscribed;
-	constructor(self, subscriberIndex, unsubscribed) {
-		this.self = self;
-		this.subscriberIndex = subscriberIndex;
-		this.unsubscribed = unsubscribed;
-	}
-	isEmpty() {
-		return this.unsubscribed || this.self.subscribers === 0 || this.subscriberIndex === this.self.publisherIndex;
-	}
-	size() {
-		return this.isEmpty() ? 0 : 1;
-	}
-	poll() {
-		if (this.isEmpty()) return Empty$2;
-		const elem = this.self.value;
-		this.self.subscribers -= 1;
-		if (this.self.subscribers === 0) this.self.value = AbsentValue;
-		this.subscriberIndex += 1;
-		return elem;
-	}
-	pollUpTo(n) {
-		if (this.isEmpty() || n < 1) return [];
-		const a = this.self.value;
-		this.self.subscribers -= 1;
-		if (this.self.subscribers === 0) this.self.value = AbsentValue;
-		this.subscriberIndex += 1;
-		return [a];
-	}
-	unsubscribe() {
-		if (!this.unsubscribed) {
-			this.unsubscribed = true;
-			this.self.subscriberCount -= 1;
-			if (this.subscriberIndex !== this.self.publisherIndex) {
-				this.self.subscribers -= 1;
-				if (this.self.subscribers === 0) this.self.value = AbsentValue;
-			}
-		}
-	}
-};
 var UnboundedPubSub = class {
 	publisherHead = {
 		value: AbsentValue,
@@ -24753,99 +24057,6 @@ var PubSubImpl = class {
 	}
 };
 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}`);
-};
-/**
-* Represents the back-pressure strategy for bounded `PubSub` values.
-*
-* **When to use**
-*
-* Use to preserve every message for current subscribers when a bounded custom
-* `PubSub` should make publishers wait for capacity instead of dropping or
-* evicting messages.
-*
-* **Details**
-*
-* Publishers wait when the `PubSub` is at capacity, so all current subscribers
-* can receive every published message.
-*
-* **Gotchas**
-*
-* A slow subscriber can slow down publishers and other subscribers.
-*
-* @see {@link bounded} for creating bounded PubSubs with back pressure by default
-* @see {@link DroppingStrategy} for dropping new messages when capacity is full
-* @see {@link SlidingStrategy} for evicting old messages when capacity is full
-*
-* @category models
-* @since 4.0.0
-*/
-var BackPressureStrategy = class {
-	publishers = /*#__PURE__*/ make$51();
-	get shutdown() {
-		return withFiber((fiber) => forEach$1(takeAll$2(this.publishers), ([_, deferred, last]) => last ? interruptWith(deferred, fiber.id) : void_$1, {
-			concurrency: "unbounded",
-			discard: true
-		}));
-	}
-	handleSurplus(pubsub, subscribers, elements, isShutdown) {
-		return suspend$2(() => {
-			const deferred = makeUnsafe$7();
-			this.offerUnsafe(elements, deferred);
-			this.onPubSubEmptySpaceUnsafe(pubsub, subscribers);
-			this.completeSubscribersUnsafe(pubsub, subscribers);
-			return (get$8(isShutdown) ? interrupt$1 : _await(deferred)).pipe(onInterrupt(() => {
-				this.removeUnsafe(deferred);
-				return void_$1;
-			}));
-		});
-	}
-	onPubSubEmptySpaceUnsafe(pubsub, subscribers) {
-		let keepPolling = true;
-		while (keepPolling && !pubsub.isFull()) {
-			const publisher = take$3(this.publishers);
-			if (publisher === Empty$2) keepPolling = false;
-			else {
-				const [value, deferred] = publisher;
-				const published = pubsub.publish(value);
-				if (published && publisher[2]) doneUnsafe(deferred, succeed$5(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(this.publishers, ([_, d]) => d !== deferred);
-	}
-};
 /**
 * Represents the dropping strategy for bounded `PubSub` values.
 *
@@ -24916,7 +24127,7 @@ var DroppingStrategy = class {
 const strategyCompletePollersUnsafe = (strategy, pubsub, subscribers, subscription, pollers) => {
 	let keepPolling = true;
 	while (keepPolling && !subscription.isEmpty()) {
-		const poller = take$3(pollers);
+		const poller = take$2(pollers);
 		if (poller === Empty$2) {
 			removeSubscribers(subscribers, subscription, pollers);
 			if (pollers.length === 0) keepPolling = false;
@@ -25224,41 +24435,43 @@ const sliding = (capacity) => make$48({
 	strategy: "sliding"
 });
 /**
-* Creates an unbounded queue that can grow to any size without blocking producers.
+* Creates a bounded queue with dropping strategy. When the queue reaches capacity,
+* new elements are dropped and the offer operation returns false.
 *
 * **When to use**
 *
-* Use when producers should never be blocked; unbounded queues never apply backpressure, so producers
-* can always add messages successfully. This is useful when you want to prioritize
-* producer throughput over memory usage control.
+* Use when producers should not block and existing messages should be preserved,
+* but new messages may be lost when the queue is full.
 *
-* **Example** (Creating unbounded queues)
+* **Example** (Creating dropping queues)
 *
 * ```ts
 * import { Effect, Queue } from "effect"
 *
 * const program = Effect.gen(function*() {
-*   const queue = yield* Queue.unbounded<string>()
+*   const queue = yield* Queue.dropping<number>(2)
 *
-*   // Producers can always add messages without blocking
-*   yield* Queue.offer(queue, "message1")
-*   yield* Queue.offer(queue, "message2")
-*   yield* Queue.offerAll(queue, ["message3", "message4", "message5"])
+*   // Fill the queue to capacity
+*   const success1 = yield* Queue.offer(queue, 1)
+*   const success2 = yield* Queue.offer(queue, 2)
+*   console.log(success1, success2) // true, true
 *
-*   // Check current size
-*   const size = yield* Queue.size(queue)
-*   console.log(size) // 5
+*   // This will be dropped
+*   const success3 = yield* Queue.offer(queue, 3)
+*   console.log(success3) // false
 *
-*   // Take all messages
-*   const messages = yield* Queue.takeAll(queue)
-*   console.log(messages) // ["message1", "message2", "message3", "message4", "message5"]
+*   const all = yield* Queue.takeAll(queue)
+*   console.log(all) // [1, 2] - element 3 was dropped
 * })
 * ```
 *
 * @category constructors
 * @since 2.0.0
 */
-const unbounded = () => make$48();
+const dropping = (capacity) => make$48({
+	capacity,
+	strategy: "dropping"
+});
 /**
 * Adds a message to the queue. Returns `false` if the queue is done.
 *
@@ -25302,7 +24515,7 @@ const offer = (self, message) => suspend$3(() => {
 			}
 			return offerRemainingSingle(self, message);
 		case "sliding":
-			take$3(self.messages);
+			take$2(self.messages);
 			append(self.messages, message);
 			return exitTrue;
 	}
@@ -25345,7 +24558,7 @@ 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);
+			take$2(self.messages);
 			append(self.messages, message);
 			return true;
 		} else if (self.capacity <= 0 && self.state.takers.size > 0) {
@@ -25750,14 +24963,14 @@ const take$1 = (self) => suspend$3(() => takeUnsafe(self) ?? andThen$1(awaitTake
 const takeUnsafe = (self) => {
 	if (self.state._tag === "Done") return self.state.exit;
 	if (self.messages.length > 0) {
-		const message = take$3(self.messages);
+		const message = take$2(self.messages);
 		releaseCapacity(self);
 		return exitSucceed(message);
 	} else if (self.capacity <= 0 && self.state.offers.size > 0) {
 		self.capacity = 1;
 		releaseCapacity(self);
 		self.capacity = 0;
-		const message = take$3(self.messages);
+		const message = take$2(self.messages);
 		releaseCapacity(self);
 		return exitSucceed(message);
 	}
@@ -25829,7 +25042,7 @@ const takeBetweenUnsafe = (self, min, max) => {
 		self.capacity = 1;
 		releaseCapacity(self);
 		self.capacity = 0;
-		const messages = [take$3(self.messages)];
+		const messages = [take$2(self.messages)];
 		releaseCapacity(self);
 		return exitSucceed(messages);
 	}
@@ -26281,21 +25494,6 @@ const fromTransformBracket = (f) => fromTransform$1(fnUntraced(function* (upstre
 * @since 4.0.0
 */
 const toTransform = (channel) => channel.transform;
-/**
-* The default chunk size used by channels for batching operations.
-*
-* **Example** (Reading the default chunk size)
-*
-* ```ts
-* import { Channel } from "effect"
-*
-* console.log(Channel.DefaultChunkSize) // 4096
-* ```
-*
-* @category constants
-* @since 4.0.0
-*/
-const DefaultChunkSize = 4096;
 const asyncQueue = (scope, f, options) => make$48({
 	capacity: options?.bufferSize,
 	strategy: options?.strategy
@@ -26336,87 +25534,6 @@ const callbackArray = (f, options) => fromTransform$1((_, scope) => map$4(asyncQ
 */
 const suspend$1 = (evaluate) => fromTransform$1((upstream, scope) => suspend$2(() => toTransform(evaluate())(upstream, scope)));
 /**
-* Creates a `Channel` from an iterator that emits arrays of elements.
-*
-* **Example** (Batching iterator output)
-*
-* ```ts
-* import { Channel } from "effect"
-*
-* // Create a channel from a simple iterator
-* const numberIterator = (): Iterator<number, string> => {
-*   let count = 0
-*   return {
-*     next: () => {
-*       if (count < 3) {
-*         return { value: count++, done: false }
-*       }
-*       return { value: "finished", done: true }
-*     }
-*   }
-* }
-*
-* const channel = Channel.fromIteratorArray(() => numberIterator(), 2)
-* // This will emit arrays: [0, 1], [2], then complete with "finished"
-* ```
-*
-* **Example** (Batching generator output)
-*
-* ```ts
-* import { Channel } from "effect"
-*
-* // Create channel from a generator function
-* function* fibonacci(): Generator<number, void, unknown> {
-*   let a = 0, b = 1
-*   for (let i = 0; i < 5; i++) {
-*     yield a
-*     ;[a, b] = [b, a + b]
-*   }
-* }
-*
-* const fibChannel = Channel.fromIteratorArray(() => fibonacci(), 3)
-* // Emits: [0, 1, 1], [2, 3], then completes
-* ```
-*
-* @category constructors
-* @since 4.0.0
-*/
-const fromIteratorArray = (iterator, chunkSize = DefaultChunkSize) => fromPull$1(sync(() => {
-	const iter = iterator();
-	let done$15 = none();
-	return suspend$2(() => {
-		if (done$15._tag === "Some") return done(done$15.value);
-		const buffer = [];
-		while (buffer.length < chunkSize) {
-			const state = iter.next();
-			if (state.done) {
-				if (buffer.length === 0) return done(state.value);
-				done$15 = some(state.value);
-				break;
-			}
-			buffer.push(state.value);
-		}
-		return succeed$3(buffer);
-	});
-}));
-/**
-* Creates a `Channel` that emits arrays of elements from an iterable.
-*
-* **Example** (Batching iterable output)
-*
-* ```ts
-* import { Channel } from "effect"
-*
-* const numbers = [1, 2, 3, 4, 5]
-* const channel = Channel.fromIterableArray(numbers)
-* // Emits arrays like: [1, 2, 3, 4], [5] (based on chunk size)
-* ```
-*
-* @category constructors
-* @since 4.0.0
-*/
-const fromIterableArray = (iterable, chunkSize = DefaultChunkSize) => fromIteratorArray(() => iterable[Symbol.iterator](), chunkSize);
-/**
 * Creates a `Channel` that emits a single value and then ends.
 *
 * **Example** (Creating channels that succeed)
@@ -27493,14 +26610,6 @@ const unwrap$3 = (channel) => fromTransform$1((upstream, scope) => {
 	}));
 });
 /**
-* Runs a channel with a scope provided for the duration of the channel
-* execution, removing the channel's `Scope` requirement.
-*
-* @category resource management
-* @since 2.0.0
-*/
-const scoped$2 = (self) => fromTransformBracket((upstream, scope, forkedScope) => map$4(provide$3(toTransform(self)(upstream, scope), forkedScope), provide$3(forkedScope)));
-/**
 * Returns a channel with an exit-aware finalizer that is guaranteed to run once
 * the channel begins execution, whether it succeeds or fails.
 *
@@ -28328,7 +27437,7 @@ const makeUnsafe$2 = (options) => ({
 */
 const make$46 = (options) => withFiber((fiber) => {
 	const context = fiber.context;
-	const scope = get$9(context, Scope);
+	const scope = get$8(context, Scope);
 	const self = makeUnsafe$2({
 		lookup: options.lookup,
 		context,
@@ -28521,7 +27630,7 @@ var RcRefImpl = class {
 /** @internal */
 const make$45 = (options) => withFiber((fiber) => {
 	const context = fiber.context;
-	const scope = get$9(context, Scope);
+	const scope = get$8(context, Scope);
 	const ref = new RcRefImpl(options.acquire, context, scope, options.idleTimeToLive ? fromInputUnsafe(options.idleTimeToLive) : void 0);
 	return as(addFinalizerExit(scope, () => {
 		const close$1 = ref.state._tag === "Acquired" ? close(ref.state.scope, void_$2) : void_$1;
@@ -28837,30 +27946,6 @@ const fromChannel = fromChannel$2;
 */
 const fromEffect = (effect) => fromChannel(fromEffect$1(map$4(effect, of)));
 /**
-* Creates a stream from an effect producing a value of type `A` which repeats forever.
-*
-* **Example** (Repeating an effect forever)
-*
-* ```ts
-* import { Console, Effect, Random, Stream } from "effect"
-*
-* const program = Effect.gen(function*() {
-*   const stream = Stream.fromEffectRepeat(Random.nextInt).pipe(
-*     Stream.take(5)
-*   )
-*   const values = yield* Stream.runCollect(stream)
-*   yield* Console.log(values)
-* })
-*
-* Effect.runPromise(program)
-* // Output: [ 3891571149, 4239494205, 2352981603, 2339111046, 1488052210 ]
-* ```
-*
-* @category constructors
-* @since 4.0.0
-*/
-const fromEffectRepeat = (effect) => fromPull(succeed$3(map$4(effect, of)));
-/**
 * Creates a stream from a pull effect, such as one produced by `Stream.toPull`.
 *
 * **Details**
@@ -29071,34 +28156,6 @@ const suspend = (stream) => fromChannel(suspend$1(() => stream().channel));
 */
 const fail$1 = (error) => fromChannel(fail$2(error));
 /**
-* Creates a new `Stream` from an iterable collection of values.
-*
-* **Details**
-*
-* - `chunkSize`: Maximum number of values emitted per chunk.
-*
-* **Example** (Creating a stream from an iterable)
-*
-* ```ts
-* import { Console, Effect, Stream } from "effect"
-*
-* const numbers = [1, 2, 3]
-*
-* const program = Effect.gen(function*() {
-*   const stream = Stream.fromIterable(numbers)
-*   const values = yield* Stream.runCollect(stream)
-*   yield* Console.log(values)
-* })
-*
-* Effect.runPromise(program)
-* // Output: [ 1, 2, 3 ]
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const fromIterable$1 = (iterable, options) => Array.isArray(iterable) && options?.chunkSize === void 0 ? fromArray(iterable) : fromChannel(fromIterableArray(iterable, options?.chunkSize));
-/**
 * Creates a stream from an array of values.
 *
 * **Example** (Creating a stream from an array of values)
@@ -29259,34 +28316,6 @@ const fromReadableStream = (options) => fromChannel(fromTransform$1(fnUntraced(f
 */
 const unwrap$1 = (effect) => fromChannel(unwrap$3(map$4(effect, toChannel)));
 /**
-* Runs a stream that requires `Scope` in a managed scope, ensuring its
-* finalizers are run when the stream completes.
-*
-* **Example** (Scoping a stream)
-*
-* ```ts
-* import { Console, Effect, Stream } from "effect"
-*
-* const stream = Stream.scoped(
-*   Stream.fromEffect(
-*     Effect.acquireRelease(
-*       Console.log("acquire").pipe(Effect.as("resource")),
-*       () => Console.log("release")
-*     )
-*   )
-* )
-*
-* Effect.runPromise(Stream.runCollect(stream)).then(console.log)
-* // acquire
-* // release
-* // [ "resource" ]
-* ```
-*
-* @category constructors
-* @since 2.0.0
-*/
-const scoped$1 = (self) => fromChannel(scoped$2(self.channel));
-/**
 * Transforms the elements of this stream using the supplied function.
 *
 * **Example** (Mapping stream values)
@@ -29489,53 +28518,6 @@ const catch_ = /*#__PURE__*/ dual(2, (self, f) => fromChannel(catch_$1(self.chan
 */
 const orDie = (self) => fromChannel(orDie$1(self.channel));
 /**
-* Takes elements until the predicate matches.
-*
-* **Details**
-*
-* When `excludeLast` is `true`, the matching element is dropped.
-*
-* **Example** (Taking until a predicate matches)
-*
-* ```ts
-* import { Console, Effect, Stream } from "effect"
-*
-* const stream = Stream.range(1, 5)
-*
-* const program = Effect.gen(function*() {
-*   const inclusive = yield* stream.pipe(
-*     Stream.takeUntil((n) => n % 3 === 0),
-*     Stream.runCollect
-*   )
-*   yield* Console.log(inclusive)
-*   // Output: [ 1, 2, 3 ]
-*
-*   const exclusive = yield* stream.pipe(
-*     Stream.takeUntil((n) => n % 3 === 0, { excludeLast: true }),
-*     Stream.runCollect
-*   )
-*   yield* Console.log(exclusive)
-*   // Output: [ 1, 2 ]
-* })
-* ```
-*
-* @category filtering
-* @since 2.0.0
-*/
-const takeUntil = /*#__PURE__*/ dual((args) => isStream(args[0]), (self, predicate, options) => transformPull(self, (pull, _scope) => sync(() => {
-	let i = 0;
-	let done$9 = false;
-	return flatMap$2(suspend$2(() => done$9 ? done() : pull), (chunk) => {
-		const index = chunk.findIndex((a) => predicate(a, i++));
-		if (index >= 0) {
-			done$9 = true;
-			const arr = chunk.slice(0, options?.excludeLast ? index : index + 1);
-			return isReadonlyArrayNonEmpty(arr) ? succeed$3(arr) : done();
-		}
-		return succeed$3(chunk);
-	});
-})));
-/**
 * Drops the first `n` elements from this stream.
 *
 * **Example** (Dropping values from the left)
@@ -30610,7 +29592,7 @@ const make$41 = (spawn) => {
 	const streamLines = (command, options) => splitLines(streamString(command, options));
 	return ChildProcessSpawner.of({
 		spawn,
-		exitCode: (command) => scoped$3(flatMap$2(spawn(command), (handle) => handle.exitCode)),
+		exitCode: (command) => scoped$1(flatMap$2(spawn(command), (handle) => handle.exitCode)),
 		streamString,
 		streamLines,
 		lines: (command, options) => runCollect(streamLines(command, options)),
@@ -31710,53 +30692,71 @@ const get$3 = (self) => sync(() => self.ref.current);
 */
 const set$4 = /*#__PURE__*/ dual(2, (self, value) => sync(() => set$6(self.ref, value)));
 /**
-* Updates the value of the Ref atomically using the given function.
+* Modifies the value of the Ref atomically using the given function.
 *
 * **When to use**
 *
-* Use to apply a state transition without returning a value.
+* Use to compute both a separate return value and the next stored value in one
+* atomic update.
 *
-* **Example** (Updating a value)
+* **Details**
+*
+* The function receives the current value and returns a tuple of
+* `[result, newValue]`. The Ref is updated with `newValue`, and `result` is
+* returned by the effect.
+*
+* **Example** (Modifying a value atomically)
 *
 * ```ts
 * import { Effect, Ref } from "effect"
 *
 * const program = Effect.gen(function*() {
-*   const counter = yield* Ref.make(5)
+*   const counter = yield* Ref.make(10)
 *
-*   // Update the value
-*   yield* Ref.update(counter, (n) => n * 2)
+*   // Modify the ref and return some computation result
+*   const result = yield* Ref.modify(counter, (n) => [
+*     `Previous value was ${n}`, // Return value
+*     n * 2 // New ref value
+*   ])
 *
-*   const value = yield* Ref.get(counter)
-*   console.log(value) // 10
+*   console.log(result) // "Previous value was 10"
+*
+*   const current = yield* Ref.get(counter)
+*   console.log(current) // 20
 * })
 *
-* // Using multiple operations
+* // Example with more complex computation
 * const program2 = Effect.gen(function*() {
-*   const counter = yield* Ref.make(5)
-*   yield* Ref.update(counter, (n: number) => n + 10)
-*   const value = yield* Ref.get(counter)
-*   console.log(value) // 15
+*   const state = yield* Ref.make({ count: 0, total: 0 })
+*
+*   const incremented = yield* Ref.modify(state, (s) => [
+*     s.count, // Return previous count
+*     { count: s.count + 1, total: s.total + s.count + 1 } // New state
+*   ])
+*
+*   console.log(incremented) // 0
 * })
 * ```
 *
-* @see {@link updateAndGet} for returning the new value
-* @see {@link getAndUpdate} for returning the previous value
+* @see {@link updateAndGet} for returning the new stored value
+* @see {@link modifySome} for optionally updating while returning a separate result
 *
 * @category setters
 * @since 2.0.0
 */
-const update$1 = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
-	self.ref.current = f(self.ref.current);
+const modify$2 = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
+	const [b, a] = f(self.ref.current);
+	self.ref.current = a;
+	return b;
 }));
 /**
-* Updates the value of the Ref atomically using the given function and returns the new value.
+* Updates the value of the Ref atomically using the given function.
 *
 * **When to use**
 *
-* Use to apply a state transition and return the new stored value.
+* Use to apply a state transition without returning a value.
 *
-* **Example** (Updating and returning the new value)
+* **Example** (Updating a value)
 *
 * ```ts
 * import { Effect, Ref } from "effect"
@@ -31764,23 +30764,31 @@ const update$1 = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
 * const program = Effect.gen(function*() {
 *   const counter = yield* Ref.make(5)
 *
-*   // Update and get the new value in one operation
-*   const newValue = yield* Ref.updateAndGet(counter, (n) => n * 3)
-*   console.log(newValue) // 15
+*   // Update the value
+*   yield* Ref.update(counter, (n) => n * 2)
 *
-*   // Verify the ref contains the new value
-*   const current = yield* Ref.get(counter)
-*   console.log(current) // 15
+*   const value = yield* Ref.get(counter)
+*   console.log(value) // 10
+* })
+*
+* // Using multiple operations
+* const program2 = Effect.gen(function*() {
+*   const counter = yield* Ref.make(5)
+*   yield* Ref.update(counter, (n: number) => n + 10)
+*   const value = yield* Ref.get(counter)
+*   console.log(value) // 15
 * })
 * ```
 *
-* @see {@link update} for updating without returning the new value
-* @see {@link getAndUpdate} for returning the previous value instead
+* @see {@link updateAndGet} for returning the new value
+* @see {@link getAndUpdate} for returning the previous value
 *
-* @category mutations
+* @category setters
 * @since 2.0.0
 */
-const updateAndGet = /*#__PURE__*/ dual(2, (self, f) => sync(() => self.ref.current = f(self.ref.current)));
+const update$1 = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
+	self.ref.current = f(self.ref.current);
+}));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/internal/hashMap.js
 /**
@@ -35040,7 +34048,7 @@ const Proto$10 = /*#__PURE__*/ Object.create(null);
 Object.defineProperties(Proto$10, {
 	[TypeId$22]: { value: TypeId$22 },
 	[symbolRedactable]: { value(context) {
-		return redact(this, get$9(context, CurrentRedactedNames));
+		return redact(this, get$8(context, CurrentRedactedNames));
 	} },
 	toJSON: { value() {
 		return redact$1(this);
@@ -39414,7 +38422,7 @@ var MultipartError = class MultipartError extends TaggedError("MultipartError")
 * @since 4.0.0
 */
 const makeConfig = (headers) => withFiber((fiber) => {
-	const mimeTypes = get$9(fiber.context, FieldMimeTypes);
+	const mimeTypes = get$8(fiber.context, FieldMimeTypes);
 	return succeed$3({
 		headers,
 		maxParts: fiber.getRef(MaxParts),
@@ -40482,7 +39490,7 @@ var MiddlewareImpl = class MiddlewareImpl {
 			const stack = [context.mapUnsafe.get(fnContextKey)];
 			if (this.dependencies) {
 				const memoMap = yield* CurrentMemoMap;
-				const scope = get$9(context, Scope);
+				const scope = get$8(context, Scope);
 				const depsContext = yield* buildWithMemoMap(this.dependencies, memoMap, scope);
 				stack.push(...getMiddleware(depsContext));
 			}
@@ -43534,7 +42542,7 @@ const makeNoSerialization = /*#__PURE__*/ fnUntraced(function* (group, options)
 	const concurrency = options.concurrency ?? "unbounded";
 	const disableFatalDefects = options.disableFatalDefects ?? false;
 	const services = yield* context$1();
-	const scope = get$9(services, Scope);
+	const scope = get$8(services, Scope);
 	const trackFiber = runIn(forkUnsafe(scope, "parallel"));
 	const concurrencySemaphore = concurrency === "unbounded" ? void 0 : yield* make$47(concurrency);
 	const clients = /* @__PURE__ */ new Map();
@@ -43731,7 +42739,7 @@ const makeNoSerialization = /*#__PURE__*/ fnUntraced(function* (group, options)
 				return flatMap$2(write, () => latch.await);
 			})),
 			step: constVoid
-		})), catchDone(() => void_$1), scoped$3);
+		})), catchDone(() => void_$1), scoped$1);
 		return runForEachArray(stream, (values) => {
 			const write = options.onFromServer({
 				_tag: "Chunk",
@@ -50250,7 +49258,7 @@ const layer$8 = /*#__PURE__*/ effect(Terminal$1, /*#__PURE__*/ (/* @__PURE__ */
 		stdin.on("keypress", handleKeypress);
 		return queue;
 	});
-	const readLine = scoped$3(flatMap$2(get$4(rlRef), (readlineInterface) => callback$1((resume) => {
+	const readLine = scoped$1(flatMap$2(get$4(rlRef), (readlineInterface) => callback$1((resume) => {
 		const onLine = (line) => resume(succeed$3(line));
 		readlineInterface.once("line", onLine);
 		return sync(() => readlineInterface.off("line", onLine));
@@ -51752,7 +50760,7 @@ const Proto = {
 * @category constructors
 * @since 2.0.0
 */
-const make$3 = (value) => map$4(unbounded$1({ replay: 1 }), (pubsub) => {
+const make$3 = (value) => map$4(unbounded({ replay: 1 }), (pubsub) => {
 	const self = Object.create(Proto);
 	self.semaphore = makeUnsafe$3(1);
 	self.value = value;
@@ -51825,6 +50833,49 @@ const setUnsafe = (self, value) => {
 	publishUnsafe(self.pubsub, value);
 };
 /**
+* Retrieves the current value and optionally updates the reference.
+*
+* **When to use**
+*
+* Use to read the old value while applying a synchronous update only when a
+* new value is available.
+*
+* **Details**
+*
+* If the function returns `Option.some`, the new value is set and published. If
+* it returns `Option.none`, the reference is left unchanged and no update is
+* published.
+*
+* **Example** (Getting and conditionally updating a value)
+*
+* ```ts
+* import { Effect, Option, SubscriptionRef } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const ref = yield* SubscriptionRef.make(10)
+*
+*   const oldValue = yield* SubscriptionRef.getAndUpdateSome(
+*     ref,
+*     (n) => n > 5 ? Option.some(n * 2) : Option.none()
+*   )
+*   console.log("Old value:", oldValue)
+*
+*   const newValue = yield* SubscriptionRef.get(ref)
+*   console.log("New value:", newValue)
+* })
+* ```
+*
+* @category getters
+* @since 2.0.0
+*/
+const getAndUpdateSome = /*#__PURE__*/ dual(2, (self, update) => self.semaphore.withPermit(sync(() => {
+	const current = self.value;
+	const option = update(current);
+	if (isNone(option)) return succeed$3(current);
+	setUnsafe(self, option.value);
+	return current;
+})));
+/**
 * Modifies the `SubscriptionRef` atomically with a function that computes a
 * return value and a new value, notifying subscribers of the change.
 *
@@ -52362,13 +51413,7 @@ var TerminalError = class extends TaggedErrorClass()("TerminalError", {
 	cause: optional(Defect),
 	message: optional(String$1)
 }) {};
-const TerminalEvent = Struct({
-	data: String$1,
-	sequence: Number$1,
-	type: Literal("data")
-});
-const TerminalState = Struct({
-	runId: Number$1,
+const TerminalStatus = Struct({
 	state: Literals([
 		"idle",
 		"starting",
@@ -52380,13 +51425,23 @@ const TerminalState = Struct({
 	]),
 	title: String$1
 });
-function terminalStateActive(state) {
+function terminalStatusActive(state) {
 	return state === "idle" || state === "starting" || state === "running" || state === "waiting";
 }
-const TerminalUpdate = Union([Struct({
-	state: TerminalState,
-	type: Literal("state")
-}), TerminalEvent]);
+const TerminalAttachUpdate = Union([
+	Struct({
+		data: String$1,
+		type: Literal("snapshot")
+	}),
+	Struct({
+		data: String$1,
+		type: Literal("data")
+	}),
+	Struct({
+		status: TerminalStatus,
+		type: Literal("status")
+	})
+]);
 //#endregion
 //#region src/rpcs/contracts.ts
 const CreateWorktreeSource = Union([
@@ -52427,7 +51482,7 @@ const AgentSession = Struct({
 		"pi"
 	]),
 	label: String$1,
-	state: TerminalState,
+	state: TerminalStatus,
 	uuid: String$1
 });
 var RpcContracts = class extends make$15(make$18("agents.create", {
@@ -52563,21 +51618,21 @@ var RpcContracts = class extends make$15(make$18("agents.create", {
 }), make$18("terminal.restart", {
 	error: TerminalError,
 	payload: TerminalPayload,
-	success: TerminalState
-}), make$18("terminal.state.watch", {
+	success: TerminalStatus
+}), make$18("terminal.status.watch", {
 	error: TerminalError,
 	payload: TerminalPayload,
 	stream: true,
-	success: TerminalState
+	success: TerminalStatus
 }), make$18("terminal.stop", {
 	error: TerminalError,
 	payload: TerminalPayload,
-	success: TerminalState
-}), make$18("terminal.watch", {
+	success: TerminalStatus
+}), make$18("terminal.attach", {
 	error: TerminalError,
 	payload: TerminalPayload,
 	stream: true,
-	success: TerminalUpdate
+	success: TerminalAttachUpdate
 })) {};
 //#endregion
 //#region ../../packages/git/src/service.ts
@@ -52588,7 +51643,7 @@ var GitCommand = class extends Service()("@deslop/git/service/GitCommand", { mak
 			command: args[0] ?? "git",
 			cwd
 		});
-		return yield* scoped$3(gen(function* () {
+		return yield* scoped$1(gen(function* () {
 			const handle = yield* pipe(spawner.spawn(make$40("git", args, {
 				cwd,
 				stderr: "pipe",
@@ -53178,7 +52233,7 @@ var GitReview = class extends Service()("@deslop/git/service/GitReview", { make:
 			command: args[0] ?? "gh",
 			cwd: config.cwd
 		});
-		return yield* scoped$3(gen(function* () {
+		return yield* scoped$1(gen(function* () {
 			const handle = yield* pipe(spawner.spawn(make$40("gh", args, {
 				cwd: config.cwd,
 				stderr: "pipe",
@@ -53439,7 +52494,7 @@ var GitCommitAction = class extends Service()("@deslop/git/service/GitCommitActi
 			command: args[0] ?? "gh",
 			cwd: config.cwd
 		});
-		return yield* scoped$3(gen(function* () {
+		return yield* scoped$1(gen(function* () {
 			const handle = yield* pipe(spawner.spawn(make$40("gh", args, {
 				cwd: config.cwd,
 				stderr: "pipe",
@@ -53812,244 +52867,172 @@ var Portless = class Portless extends Service()("@deslop/portless/Portless", { m
 	});
 };
 //#endregion
-//#region ../../packages/terminal/src/service.ts
-var import_addon_progress = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
-	(function(e, t) {
-		"object" == typeof exports && "object" == typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define([], t) : "object" == typeof exports ? exports.ProgressAddon = t() : e.ProgressAddon = t();
-	})(globalThis, (() => (() => {
-		"use strict";
-		var e = {};
-		return (() => {
-			var t = e;
-			function s(e) {
-				let t = 0;
-				for (let s = 0; s < e.length; ++s) {
-					const r = e.charCodeAt(s);
-					if (r < 48 || 57 < r) return -1;
-					t = 10 * t + r - 48;
-				}
-				return t;
-			}
-			Object.defineProperty(t, "__esModule", { value: !0 }), t.ProgressAddon = void 0, t.ProgressAddon = class {
-				constructor() {
-					this._st = 0, this._pr = 0;
-				}
-				dispose() {
-					this._seqHandler?.dispose(), this._onChange?.dispose();
-				}
-				activate(e) {
-					this._seqHandler = e.parser.registerOscHandler(9, ((e) => {
-						if (!e.startsWith("4;")) return !1;
-						const t = e.split(";");
-						if (t.length > 3) return !0;
-						2 === t.length && t.push("");
-						const r = s(t[1]), o = s(t[2]);
-						switch (r) {
-							case 0:
-								this.progress = {
-									state: r,
-									value: 0
-								};
-								break;
-							case 1:
-								if (o < 0) return !0;
-								this.progress = {
-									state: r,
-									value: o
-								};
-								break;
-							case 2:
-							case 4:
-								if (o < 0) return !0;
-								this.progress = {
-									state: r,
-									value: o || this._pr
-								};
-								break;
-							case 3: this.progress = {
-								state: r,
-								value: this._pr
-							};
-						}
-						return !0;
-					})), this._onChange = new e._core._onData.constructor(), this.onChange = this._onChange.event;
-				}
-				get progress() {
-					return {
-						state: this._st,
-						value: this._pr
-					};
-				}
-				set progress(e) {
-					e.state < 0 || e.state > 4 ? console.warn("progress state out of bounds, not applied") : (this._st = e.state, this._pr = Math.min(Math.max(e.value, 0), 100), this._onChange?.fire({
-						state: this._st,
-						value: this._pr
-					}));
-				}
-			};
-		})(), e;
-	})()));
-})))(), 1);
-const terminalReset = "\x1Bc";
-function parseTitleSignal(title) {
+//#region ../../packages/terminal/src/model.ts
+const terminalReplayBytes = 8 * 1024 * 1024;
+const terminalChunkBytes = 64 * 1024;
+const terminalOscCarryBytes = 4096;
+function terminalByteLength(data) {
+	return Buffer.byteLength(data);
+}
+function terminalChunks(data, chunkSize = terminalChunkBytes) {
+	if (data === "") return empty$13();
+	return pipe(range(0, Math.floor((data.length - 1) / chunkSize)), map$7((index) => data.slice(index * chunkSize, (index + 1) * chunkSize)));
+}
+function terminalReplayPush(ring, data, maxBytes = terminalReplayBytes) {
+	let chunks = [...ring, data];
+	let bytes = chunks.reduce((total, chunk) => total + terminalByteLength(chunk), 0);
+	while (bytes > maxBytes) {
+		const head = chunks[0];
+		if (head === void 0) break;
+		const excess = bytes - maxBytes;
+		const headBytes = terminalByteLength(head);
+		if (headBytes <= excess) {
+			chunks = chunks.slice(1);
+			bytes -= headBytes;
+			continue;
+		}
+		let offset = Math.min(head.length, excess);
+		while (offset < head.length && terminalByteLength(head.slice(offset)) > maxBytes - (bytes - headBytes)) offset += 1;
+		chunks[0] = head.slice(offset);
+		bytes = chunks.reduce((total, chunk) => total + terminalByteLength(chunk), 0);
+	}
+	return chunks;
+}
+function terminalTitleStatus(title) {
 	const trimmed = title.trim();
-	if (/^\[\s*[!.]\s*\]\s*Action Required\b/iu.test(trimmed)) return {
-		state: "waiting",
-		title: trimmed.replace(/^\[\s*[!.]\s*\]\s*/iu, "") || trimmed
-	};
-	const spinner = /^(?:[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏|/\\-])(?:\s|\s*\|)/u.test(trimmed);
-	const nextTitle = trimmed.replace(/^OC\s*\|\s*/iu, "").replace(/^π\s*-\s*/iu, "").replace(/^\[\s*[^\]]+\s*\]\s*/u, "").replace(/^(?:[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏|/\\-]\s*)+/u, "").replace(/^\|\s*/u, "").trim() || trimmed;
-	const segment = /^(Idle|Ready|Starting|Working|Thinking|Waiting)\b/iu.exec(nextTitle)?.[1]?.toLowerCase();
-	if (segment === "idle" || segment === "ready") return {
+	if (trimmed === "") return {
 		state: "idle",
-		title: nextTitle
-	};
-	if (segment === "starting") return {
-		state: "starting",
-		title: nextTitle
+		title: ""
 	};
-	if (segment === "waiting") return {
+	if (/^\[\s*[!.]\s*\]\s*Action Required\b/iu.test(trimmed)) return {
 		state: "waiting",
-		title: nextTitle
+		title: trimmed.replace(/^\[\s*[!.]\s*\]\s*/iu, "") || trimmed
 	};
-	if (segment === "working" || segment === "thinking" || spinner) return {
+	return {
 		state: "running",
-		title: nextTitle
-	};
-	if (trimmed !== "") return {
-		state: "idle",
-		title: nextTitle
+		title: trimmed
 	};
+}
+function terminalProgressStatus(value) {
+	const progressState = Number.parseInt(value, 10);
+	if (progressState === 0) return "idle";
+	if (progressState === 2) return "failed";
+	if (progressState === 4) return "waiting";
+	return "running";
+}
+function terminalOscUpdates(data, carry = "") {
+	const input = `${carry}${data}`;
+	const updates = [];
+	let nextCarry = "";
+	for (let index = 0; index < input.length; index += 1) {
+		if (input.charCodeAt(index) !== 27) continue;
+		if (index === input.length - 1) {
+			nextCarry = input.slice(index);
+			break;
+		}
+		if (input[index + 1] !== "]") continue;
+		const start = index + 2;
+		let end = input.indexOf("\x07", start);
+		let skip = 1;
+		const st = input.indexOf("\x1B\\", start);
+		if (end === -1 || st !== -1 && st < end) {
+			end = st;
+			skip = 2;
+		}
+		if (end === -1) {
+			nextCarry = input.slice(index);
+			break;
+		}
+		const payload = input.slice(start, end);
+		const separator = payload.indexOf(";");
+		const command = separator === -1 ? payload : payload.slice(0, separator);
+		const value = separator === -1 ? "" : payload.slice(separator + 1);
+		if (command === "0" || command === "2") updates.push({
+			title: value,
+			type: "title"
+		});
+		if (command === "9" && value.startsWith("4;")) updates.push({
+			state: terminalProgressStatus(value.slice(2)),
+			type: "progress"
+		});
+		index = end + skip - 1;
+	}
 	return {
-		state: "idle",
-		title: ""
+		carry: terminalByteLength(nextCarry) > terminalOscCarryBytes ? "" : nextCarry,
+		updates
 	};
 }
-function snapshotEvents(data, sequence) {
-	if (data === "") return empty$13();
-	return pipe(range(0, Math.floor((data.length - 1) / (256 * 1024))), map$7((index) => ({
-		data: data.slice(index * 256 * 1024, (index + 1) * 256 * 1024),
-		sequence,
-		type: "data"
-	})));
-}
-function adjacentGroups(items, sameGroup, merge) {
+//#endregion
+//#region ../../packages/terminal/src/service.ts
+function mergeWrites(items) {
 	return pipe(items, reduce(empty$13(), (groups, item) => {
 		const previous = groups.at(-1);
-		if (previous === void 0 || !sameGroup(previous, item)) return append$1(groups, item);
-		return append$1(dropRight(groups, 1), merge(previous, item));
+		if (previous === void 0 || previous.process !== item.process) return append$1(groups, item);
+		return append$1(dropRight(groups, 1), {
+			data: `${previous.data}${item.data}`,
+			process: item.process
+		});
 	}));
 }
-function queuedDataGroups(items, merge) {
-	return adjacentGroups(items, (previous, item) => previous.generation === item.generation, merge);
-}
-function mergeQueuedData(previous, item) {
-	return {
-		data: `${previous.data}${item.data}`,
-		generation: item.generation
-	};
+function pauseProcess(subprocess) {
+	if ("pause" in subprocess && typeof subprocess.pause === "function") subprocess.pause();
 }
-function queuedWriteGroups(items) {
-	return adjacentGroups(items, (previous, item) => previous.process === item.process, (previous, item) => ({
-		data: `${previous.data}${item.data}`,
-		process: item.process
-	}));
+function resumeProcess(subprocess) {
+	if ("resume" in subprocess && typeof subprocess.resume === "function") subprocess.resume();
 }
 var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { make: fnUntraced(function* (config) {
-	const dataQueue = yield* unbounded();
-	const writeQueue = yield* unbounded();
+	const dataQueue = yield* bounded(128);
+	const writeQueue = yield* bounded(128);
 	const resizeQueue = yield* sliding(1);
-	const events = yield* bounded$1(1024);
 	const lifecycleLock = yield* make$47(1);
-	const screenLock = yield* make$47(1);
-	const eventSequenceRef = yield* make$38(0);
-	const parsedSequenceRef = yield* make$38(0);
-	const screenGenerationRef = yield* make$38(0);
 	const processRef = yield* make$38(void 0);
+	const replayProcessRef = yield* make$38(void 0);
 	const sizeRef = yield* make$38({
 		cols: 120,
 		rows: 32
 	});
+	const replayRef = yield* make$38(empty$13());
+	const oscRef = yield* make$38("");
+	const attachRef = yield* make$38(void 0);
 	const shell = yield* string("SHELL").pipe(orElseSucceed(() => "bash"));
 	const processCommand = config.command?.command ?? shell;
 	const processArgs = config.command?.args ?? [];
 	const processEnv = config.command?.options.env ?? {};
 	const autostart = config.command === void 0;
-	const stateRef = yield* make$3({
-		runId: 0,
+	const statusRef = yield* make$3({
 		state: autostart ? "starting" : "idle",
 		title: ""
 	});
-	const screen = new HeadlessModule.Terminal({
-		allowProposedApi: true,
-		cols: 120,
-		rows: 32,
-		scrollback: 1e4
-	});
-	const serialize = new SerializeModule.SerializeAddon();
-	const progressAddon = new import_addon_progress.ProgressAddon();
-	screen.loadAddon(serialize);
-	screen.loadAddon(progressAddon);
-	const publish$1 = fnUntraced(function* (data) {
-		const sequence = yield* updateAndGet(eventSequenceRef, (current) => current + 1);
-		yield* publish(events, {
-			data,
-			sequence,
-			type: "data"
+	const publishStatus = fnUntraced(function* (status) {
+		const previous = yield* getAndUpdateSome(statusRef, (current) => current.state === status.state && current.title === status.title ? none() : some(status));
+		if (previous.state === status.state && previous.title === status.title) return;
+		const attach = yield* get$3(attachRef);
+		if (attach) yield* offer(attach, {
+			status,
+			type: "status"
 		});
-		return sequence;
 	});
-	const requestSnapshot = withPermit(screenLock, gen(function* () {
-		return {
-			data: serialize.serialize({ scrollback: 1e4 }),
-			sequence: yield* get$3(parsedSequenceRef)
-		};
-	}));
-	function setState(state) {
-		return update(stateRef, (current) => current.state === state ? current : {
+	function setStatus(state) {
+		return get(statusRef).pipe(flatMap$2((current) => publishStatus({
 			...current,
 			state
-		});
-	}
-	function setProgressState(progressState) {
-		return update(stateRef, (current) => {
-			if (current.state === "stopped" || current.state === "exited" || current.state === "failed") return current;
-			const state = pipe(progressState.state, value, when(0, () => "idle"), when(2, () => "failed"), when(4, () => "waiting"), orElse(() => "running"));
-			if (current.state === state) return current;
-			return {
-				...current,
-				state
-			};
-		});
+		})));
 	}
 	function setTitle(title) {
-		return update(stateRef, (current) => {
-			if (!terminalStateActive(current.state)) return current;
-			const next = parseTitleSignal(title);
-			if (current.state === next.state && current.title === next.title) return current;
-			return {
+		return get(statusRef).pipe(flatMap$2((current) => {
+			if (!terminalStatusActive(current.state)) return void_$1;
+			return publishStatus({
 				...current,
-				...next
-			};
-		});
+				...terminalTitleStatus(title)
+			});
+		}));
+	}
+	function setProgress(state) {
+		return get(statusRef).pipe(flatMap$2((current) => terminalStatusActive(current.state) ? publishStatus({
+			...current,
+			state
+		}) : void_$1));
 	}
-	const startRun = pipe(update(stateRef, (state) => ({
-		...state,
-		runId: state.runId + 1,
-		state: "starting",
-		title: ""
-	})), andThen(get(stateRef)));
-	screen.parser.registerOscHandler(0, (title) => {
-		runFork(setTitle(title));
-		return false;
-	});
-	screen.parser.registerOscHandler(2, (title) => {
-		runFork(setTitle(title));
-		return false;
-	});
-	progressAddon.onChange((nextProgress) => {
-		runFork(setProgressState(nextProgress));
-	});
 	const interruptProcess = fnUntraced(function* (subprocess, signal) {
 		yield* sync(() => {
 			try {
@@ -54062,23 +53045,13 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		yield* sleep("250 millis");
 		yield* interruptProcess(subprocess, "SIGKILL");
 	});
-	const writeScreen = fnUntraced(function* (input) {
-		if ((yield* get$3(screenGenerationRef)) !== input.generation) return;
-		yield* withPermit(screenLock, pipe(callback$1((resume) => {
-			screen.write(input.data, () => {
-				resume(succeed$3(void 0));
-			});
-		}), andThen(gen(function* () {
-			if ((yield* get$3(screenGenerationRef)) === input.generation) yield* set$4(parsedSequenceRef, yield* publish$1(input.data));
-		}))));
-	});
 	const clearProcess = fnUntraced(function* (handle) {
 		yield* update$1(processRef, (current) => current === handle ? void 0 : current);
 	});
 	const stopProcess = fnUntraced(function* (state) {
 		const handle = yield* get$3(processRef);
 		if (!handle) {
-			if (state) yield* setState(state);
+			if (state) yield* setStatus(state);
 			return;
 		}
 		yield* sync(() => {
@@ -54087,14 +53060,22 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		});
 		yield* clearProcess(handle);
 		yield* pipe(terminateProcess(handle.process), ignore$1);
-		if (state) yield* setState(state);
+		if (state) yield* setStatus(state);
 	});
 	const spawnProcess = fnUntraced(function* () {
-		const generation = yield* updateAndGet(screenGenerationRef, (current) => current + 1);
-		yield* withPermit(screenLock, pipe(sync(() => {
-			screen.reset();
-		}), andThen(publish$1(terminalReset)), tap((sequence) => set$4(parsedSequenceRef, sequence))));
-		yield* startRun;
+		yield* stopProcess();
+		yield* set$4(replayProcessRef, void 0);
+		yield* set$4(replayRef, ["\x1Bc"]);
+		yield* set$4(oscRef, "");
+		yield* publishStatus({
+			state: "starting",
+			title: ""
+		});
+		const attach = yield* get$3(attachRef);
+		if (attach) yield* offer(attach, {
+			data: "\x1Bc",
+			type: "data"
+		});
 		const size = yield* get$3(sizeRef);
 		const subprocess = yield* try_({
 			catch: (cause) => new TerminalError({
@@ -54115,54 +53096,36 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		});
 		const handle = {
 			data: subprocess.onData((chunk) => {
-				offerUnsafe(dataQueue, {
+				const output = {
 					data: chunk,
-					generation
-				});
+					process: subprocess
+				};
+				if (offerUnsafe(dataQueue, output)) return;
+				pauseProcess(subprocess);
+				runFork(offer(dataQueue, output).pipe(andThen(sync(() => resumeProcess(subprocess)))));
 			}),
 			exit: subprocess.onExit((event) => {
 				runFork(withPermit(lifecycleLock, gen(function* () {
 					if ((yield* get$3(processRef)) !== handle) return;
 					yield* clearProcess(handle);
 					if (autostart) {
-						yield* pipe(sleep("1 second"), andThen(spawnProcess()), catch_$2(() => setState("failed")));
+						yield* pipe(sleep("1 second"), andThen(spawnProcess()), catch_$2(() => setStatus("failed")));
 						return;
 					}
-					yield* setState(event.exitCode === 0 ? "exited" : "failed");
+					yield* setStatus(event.exitCode === 0 ? "exited" : "failed");
 				})));
 			}),
 			process: subprocess
 		};
 		yield* set$4(processRef, handle);
-		yield* setState("running");
-		return yield* get(stateRef);
-	});
-	const startProcess = fnUntraced(function* () {
-		yield* stopProcess();
-		return yield* spawnProcess();
+		yield* set$4(replayProcessRef, subprocess);
+		yield* setStatus("running");
+		return yield* get(statusRef);
 	});
-	yield* pipe(fromQueue(dataQueue), groupedWithin(256, millis(16)), runForEach((items) => forEach$1(queuedDataGroups(fromIterable$2(items), mergeQueuedData), writeScreen, { discard: true })), forkScoped);
-	yield* addFinalizer(() => all([
-		stopProcess(),
-		shutdown$1(events),
-		shutdown(dataQueue),
-		shutdown(writeQueue),
-		shutdown(resizeQueue),
-		sync(() => {
-			screen.dispose();
-		})
-	], {
-		concurrency: "unbounded",
-		discard: true
-	}));
-	if (autostart) yield* pipe(startProcess(), withPermit(lifecycleLock), catch_$2(() => setState("failed")));
 	const resizeProcess = fnUntraced(function* (nextSize) {
 		const size = yield* get$3(sizeRef);
 		if (size.cols === nextSize.cols && size.rows === nextSize.rows) return;
 		yield* set$4(sizeRef, nextSize);
-		yield* withPermit(screenLock, sync(() => {
-			screen.resize(nextSize.cols, nextSize.rows);
-		}));
 		const process = yield* get$3(processRef);
 		if (!process) return;
 		yield* try_({
@@ -54175,10 +53138,6 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 			}
 		});
 	});
-	yield* pipe(fromQueue(resizeQueue), groupedWithin(32, millis(16)), runForEach((items) => pipe(last(fromIterable$2(items)), match$4({
-		onNone: () => void_$1,
-		onSome: resizeProcess
-	}))), forkScoped);
 	const writeProcess = fnUntraced(function* (input) {
 		if ((yield* get$3(processRef)) !== input.process) return;
 		yield* try_({
@@ -54191,42 +53150,77 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 			}
 		});
 	});
-	yield* pipe(fromQueue(writeQueue), groupedWithin(128, millis(4)), runForEach((items) => forEach$1(queuedWriteGroups(fromIterable$2(items)), writeProcess, { discard: true })), forkScoped);
-	const eventsStream = scoped$1(unwrap$1(gen(function* () {
-		const subscription = yield* subscribe(events);
-		const snapshot = yield* requestSnapshot;
-		const pending = yield* takeUpTo(subscription, Number.POSITIVE_INFINITY);
-		const replay = filter$1(pending, (event) => event.sequence > snapshot.sequence);
-		const replaySequence = replay.at(-1)?.sequence ?? snapshot.sequence;
-		return pipe(fromIterable$1([
-			{
-				data: terminalReset,
-				sequence: snapshot.sequence,
+	yield* pipe(fromQueue(dataQueue), groupedWithin(128, millis(16)), runForEach((items) => forEach$1(fromIterable$2(items), (output) => gen(function* () {
+		if ((yield* get$3(replayProcessRef)) !== output.process) return;
+		for (const chunk of terminalChunks(output.data)) {
+			yield* update$1(replayRef, (ring) => terminalReplayPush(ring, chunk));
+			const updates = yield* modify$2(oscRef, (carry) => {
+				const parsed = terminalOscUpdates(chunk, carry);
+				return [parsed.updates, parsed.carry];
+			});
+			for (const update of updates) yield* update.type === "title" ? setTitle(update.title) : setProgress(update.state);
+			const attach = yield* get$3(attachRef);
+			if (attach) yield* offer(attach, {
+				data: chunk,
 				type: "data"
-			},
-			...snapshotEvents(snapshot.data, snapshot.sequence),
-			...replay,
-			...filter$1(pending, (event) => event.sequence > replaySequence)
-		]), concat(fromEffectRepeat(take$2(subscription))));
-	})));
-	const stateUpdates = unwrap$1(pipe(get(stateRef), map$4((state) => concat(drop(1)(changes(stateRef)))(make$43(state)))));
-	const updates = merge$1(stateUpdates.pipe(map$2((state) => ({
-		state,
-		type: "state"
-	}))), eventsStream);
+			});
+		}
+	}), { discard: true })), forkScoped);
+	yield* pipe(fromQueue(resizeQueue), groupedWithin(32, millis(16)), runForEach((items) => pipe(last(fromIterable$2(items)), match$4({
+		onNone: () => void_$1,
+		onSome: resizeProcess
+	}))), forkScoped);
+	yield* pipe(fromQueue(writeQueue), groupedWithin(128, millis(4)), runForEach((items) => forEach$1(mergeWrites(fromIterable$2(items)), writeProcess, { discard: true })), forkScoped);
+	yield* addFinalizer(() => all([
+		stopProcess(),
+		shutdown(dataQueue),
+		shutdown(writeQueue),
+		shutdown(resizeQueue),
+		get$3(attachRef).pipe(flatMap$2((queue) => queue ? end(queue) : void_$1))
+	], {
+		concurrency: "unbounded",
+		discard: true
+	}));
+	if (autostart) yield* pipe(spawnProcess(), withPermit(lifecycleLock), catch_$2(() => setStatus("failed")));
+	const attachQueue = gen(function* () {
+		const previous = yield* get$3(attachRef);
+		const queue = yield* dropping(16);
+		yield* offer(queue, {
+			status: yield* get(statusRef),
+			type: "status"
+		});
+		yield* offer(queue, {
+			data: pipe(yield* get$3(replayRef), join$2("")),
+			type: "snapshot"
+		});
+		yield* set$4(attachRef, queue);
+		if (previous) yield* end(previous);
+		yield* addFinalizer(() => update$1(attachRef, (current) => current === queue ? void 0 : current).pipe(andThen(end(queue))));
+		return queue;
+	});
+	const statusQueue = gen(function* () {
+		const queue = yield* sliding(1);
+		yield* addFinalizer(() => end(queue));
+		yield* offer(queue, yield* get(statusRef));
+		yield* pipe(changes(statusRef), drop(1), groupedWithin(32, millis(250)), runForEach((items) => pipe(last(fromIterable$2(items)), match$4({
+			onNone: () => void_$1,
+			onSome: (status) => offer(queue, status)
+		}))), forkScoped);
+		return queue;
+	});
 	return {
+		attachQueue,
 		resize: fnUntraced(function* (size) {
 			yield* offer(resizeQueue, size);
 		}),
 		restart: fnUntraced(function* () {
-			return yield* pipe(startProcess(), withPermit(lifecycleLock), catch_$2(() => pipe(setState("failed"), andThen(get(stateRef)))));
+			return yield* pipe(spawnProcess(), withPermit(lifecycleLock), catch_$2(() => pipe(setStatus("failed"), andThen(get(statusRef)))));
 		}),
-		stateUpdates,
+		statusQueue,
 		stop: fnUntraced(function* () {
 			yield* pipe(stopProcess("stopped"), withPermit(lifecycleLock));
-			return yield* get(stateRef);
+			return yield* get(statusRef);
 		}),
-		updates,
 		write: fnUntraced(function* (data) {
 			if (data === "") return;
 			const process = yield* get$3(processRef);
@@ -54256,6 +53250,9 @@ const AgentSessionKey = Struct({
 	cwd: String$1,
 	uuid: String$1
 });
+function terminalStatusDone(state) {
+	return !terminalStatusActive(state.state);
+}
 function terminalSessionInput(session) {
 	if ("args" in session || "env" in session) return {
 		command: session.command === void 0 ? void 0 : make$40(session.command, session.args ?? [], { env: session.env }),
@@ -54276,19 +53273,19 @@ function terminalSessionInput(session) {
 const TerminalSessions = make$46({
 	idleTimeToLive: infinity,
 	lookup: fnUntraced(function* (config) {
-		return get$9(yield* buildWithScope(Terminal.layer(config), yield* scope), Terminal);
+		return get$8(yield* buildWithScope(Terminal.layer(config), yield* scope), Terminal);
 	})
 });
 const GitReviewSessions = make$46({
 	idleTimeToLive: zero$1,
 	lookup: fnUntraced(function* (cwd) {
-		return get$9(yield* buildWithScope(pipe(GitReview.layer({ cwd }), provide$2(GitCommand.layer)), yield* scope), GitReview);
+		return get$8(yield* buildWithScope(pipe(GitReview.layer({ cwd }), provide$2(GitCommand.layer)), yield* scope), GitReview);
 	})
 });
 const GitCommitSessions = make$46({
 	idleTimeToLive: minutes(5),
 	lookup: fnUntraced(function* (cwd) {
-		return get$9(yield* buildWithScope(pipe(GitCommitAction.layer({ cwd }), provide$2(GitCommand.layer)), yield* scope), GitCommitAction);
+		return get$8(yield* buildWithScope(pipe(GitCommitAction.layer({ cwd }), provide$2(GitCommand.layer)), yield* scope), GitCommitAction);
 	})
 });
 const RpcHandlers = RpcContracts.toLayer(gen(function* () {
@@ -54341,7 +53338,7 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 	}) });
 	const updateReviewState = fn("RpcHandlers.updateReviewState")(function* (cwd, f) {
 		yield* annotateCurrentSpan({ cwd });
-		return yield* pipe(scoped$3(gen(function* () {
+		return yield* pipe(scoped$1(gen(function* () {
 			yield* modify(yield* get$6(reviewStates, cwd), (current) => {
 				const next = f(current);
 				return [next, next];
@@ -54372,7 +53369,6 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 				icon: payload.icon,
 				label: `${payload.label} ${labelCount + 1}`,
 				state: {
-					runId: 0,
 					state: "starting",
 					title: ""
 				},
@@ -54382,33 +53378,34 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 				cwd: agentSession.cwd,
 				uuid: agentSession.uuid
 			}), agentSession));
-			const sessionTerminal = yield* terminalSession(TerminalSessionKey.make({
+			const input = yield* terminalSession(TerminalSessionKey.make({
 				args: agentSession.args,
 				command: agentSession.command,
 				cwd: agentSession.cwd,
 				sessionId: agentSession.uuid
-			})).pipe(map$4(terminalSessionInput), flatMap$2((input) => get$6(terminals, input)));
+			})).pipe(map$4(terminalSessionInput));
+			const sessionTerminal = yield* get$6(terminals, input);
 			yield* sessionTerminal.restart();
-			yield* pipe(sessionTerminal.stateUpdates, takeUntil((state) => state.state === "exited" || state.state === "failed" || state.state === "stopped"), runForEach((state) => gen(function* () {
-				const key = AgentSessionKey.make({
-					cwd: agentSession.cwd,
-					uuid: agentSession.uuid
+			const key = AgentSessionKey.make({
+				cwd: agentSession.cwd,
+				uuid: agentSession.uuid
+			});
+			yield* pipe(scoped$1(gen(function* () {
+				const states = yield* sessionTerminal.statusQueue;
+				let done = false;
+				yield* whileLoop({
+					body: () => flatMap$2(take$1(states), (state) => pipe(update(agents, (sessions) => modifyAt(sessions, key, match$4({
+						onNone: () => none(),
+						onSome: (session) => some({
+							...session,
+							state
+						})
+					}))), andThen(terminalStatusDone(state) ? pipe(update(agents, (sessions) => remove$2(sessions, key)), andThen(pipe(invalidate(terminals, input), ignore$1))) : void_$1), as(state))),
+					step(state) {
+						done = terminalStatusDone(state);
+					},
+					while: () => !done
 				});
-				yield* update(agents, (sessions) => modifyAt(sessions, key, match$4({
-					onNone: () => none(),
-					onSome: (session) => some({
-						...session,
-						state
-					})
-				})));
-				if (state.state !== "exited" && state.state !== "failed" && state.state !== "stopped") return;
-				yield* update(agents, (sessions) => remove$2(sessions, key));
-				yield* pipe(invalidate(terminals, terminalSessionInput({
-					args: agentSession.args,
-					command: agentSession.command,
-					cwd: agentSession.cwd,
-					sessionId: agentSession.uuid
-				})), ignore$1);
 			})), forkDetach);
 			return agentSession;
 		}),
@@ -54442,14 +53439,14 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 		} })),
 		"review.state.watch": (payload) => unwrap$1(pipe(get$6(reviewStates, payload.cwd), flatMap$2((ref) => pipe(get(ref), map$4((state) => concat(drop(1)(changes(ref)))(make$43(state))))))),
 		"runs.portless": (payload) => get$6(portlessWorktrees, payload.cwd),
+		"terminal.attach": (payload) => flatMap$2(getTerminal(TerminalSessionKey.make(payload)), (sessionTerminal) => sessionTerminal.attachQueue),
 		"terminal.resize": (payload) => pipe(getTerminal(TerminalSessionKey.make(payload)), flatMap$2((sessionTerminal) => sessionTerminal.resize({
 			cols: payload.cols,
 			rows: payload.rows
 		}))),
 		"terminal.restart": (payload) => flatMap$2(getTerminal(TerminalSessionKey.make(payload)), (sessionTerminal) => sessionTerminal.restart()),
-		"terminal.state.watch": (payload) => unwrap$1(map$4(getTerminal(TerminalSessionKey.make(payload)), (sessionTerminal) => sessionTerminal.stateUpdates)),
+		"terminal.status.watch": (payload) => flatMap$2(getTerminal(TerminalSessionKey.make(payload)), (sessionTerminal) => sessionTerminal.statusQueue),
 		"terminal.stop": (payload) => flatMap$2(getTerminal(TerminalSessionKey.make(payload)), (sessionTerminal) => sessionTerminal.stop()),
-		"terminal.watch": (payload) => unwrap$1(map$4(getTerminal(TerminalSessionKey.make(payload)), (sessionTerminal) => sessionTerminal.updates)),
 		"terminal.write": (payload) => pipe(getTerminal(TerminalSessionKey.make(payload)), flatMap$2((sessionTerminal) => sessionTerminal.write(payload.data)))
 	});
 }));