@deslop/workbench 0.0.286 → 0.0.291

package/dist/server.js

@@ -12,12 +12,17 @@ import * as fs from "fs";
 import * as path from "path";
 import * as zlib from "zlib";
 import * as Crypto$1 from "node:crypto";
+import { randomUUID } from "node:crypto";
 import * as NFS from "node:fs";
 import * as OS from "node:os";
 import * as Path from "node:path";
+import { join } from "node:path";
 import * as NodeStreamP from "node:stream/promises";
 import { pipeline } from "node:stream/promises";
+import { readFile } from "node:fs/promises";
 import * as readline from "node:readline";
+import nodeProcess from "node:process";
+import * as nodePty from "@lydell/node-pty";
 //#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -5437,7 +5442,43 @@ const flatMap$5 = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none() : f(s
 * @category filtering
 * @since 2.0.0
 */
-const filter$2 = /*#__PURE__*/ dual(2, (self, predicate) => isNone(self) ? none() : predicate(self.value) ? some(self.value) : none());
+const filter$3 = /*#__PURE__*/ dual(2, (self, predicate) => isNone(self) ? none() : predicate(self.value) ? some(self.value) : none());
+/**
+* Lifts a `Predicate` or `Refinement` into the `Option` context: returns
+* `Some(value)` when the predicate holds, `None` otherwise.
+*
+* **When to use**
+*
+* Use to convert a boolean check into an `Option`-returning function
+* - Validating input and wrapping it in `Option`
+*
+* **Details**
+*
+* - `predicate(value)` is `true` → `Some(value)`
+* - `predicate(value)` is `false` → `None`
+* - Supports refinements for type narrowing
+*
+* **Example** (Validating positive numbers)
+*
+* ```ts
+* import { Option } from "effect"
+*
+* const parsePositive = Option.liftPredicate((n: number) => n > 0)
+*
+* console.log(parsePositive(1))
+* // Output: { _id: 'Option', _tag: 'Some', value: 1 }
+*
+* console.log(parsePositive(-1))
+* // Output: { _id: 'Option', _tag: 'None' }
+* ```
+*
+* @see {@link filter} to apply a predicate to an existing `Option`
+* @see {@link toRefinement} for the inverse direction
+*
+* @category lifting
+* @since 2.0.0
+*/
+const liftPredicate = /*#__PURE__*/ dual(2, (b, predicate) => predicate(b) ? some(b) : none());
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Result.js
 /**
@@ -6713,6 +6754,43 @@ const getSuccesses = (self) => {
 	return out;
 };
 /**
+* Keeps transformed values for elements where a `Filter` succeeds.
+*
+* **When to use**
+*
+* Use to transform elements with a `Result`-returning filter while discarding
+* failures.
+*
+* **Details**
+*
+* - The filter receives `(element, index)`.
+* - Failures are discarded.
+*
+* **Example** (Filter and transform)
+*
+* ```ts
+* import { Array, Result } from "effect"
+*
+* console.log(Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid))
+* // [20, 40]
+* ```
+*
+* @see {@link filter} — keep original elements matching a predicate
+* @see {@link partition} for keeping both failures and successes
+*
+* @category filtering
+* @since 2.0.0
+*/
+const filterMap = /*#__PURE__*/ dual(2, (self, f) => {
+	const as = fromIterable$2(self);
+	const out = [];
+	for (let i = 0; i < as.length; i++) {
+		const result = f(as[i], i);
+		if (isSuccess$1(result)) out.push(result.success);
+	}
+	return out;
+});
+/**
 * Keeps only elements satisfying a predicate (or refinement).
 *
 * **When to use**
@@ -6738,7 +6816,7 @@ const getSuccesses = (self) => {
 * @category filtering
 * @since 2.0.0
 */
-const filter$1 = /*#__PURE__*/ dual(2, (self, predicate) => {
+const filter$2 = /*#__PURE__*/ dual(2, (self, predicate) => {
 	const as = fromIterable$2(self);
 	const out = [];
 	for (let i = 0; i < as.length; i++) if (predicate(as[i], i)) out.push(as[i]);
@@ -6887,7 +6965,7 @@ const dedupe = (self) => dedupeWith(self, asEquivalence());
 * @category folding
 * @since 2.0.0
 */
-const join$2 = /*#__PURE__*/ dual(2, (self, sep) => fromIterable$2(self).join(sep));
+const join$3 = /*#__PURE__*/ dual(2, (self, sep) => fromIterable$2(self).join(sep));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Effectable.js
 /**
@@ -13794,6 +13872,76 @@ const endsWith = (searchString, position) => (self) => self.endsWith(searchStrin
 * @since 2.0.0
 */
 const replaceAll = (searchValue, replaceValue) => (self) => self.replaceAll(searchValue, replaceValue);
+const CR = 13;
+const LF = 10;
+/**
+* Returns an `IterableIterator` which yields each line contained within the
+* string, trimming off the trailing newline character.
+*
+* **Example** (Iterating lines without separators)
+*
+* ```ts
+* import { String } from "effect"
+*
+* const lines = String.linesIterator("hello\nworld\n")
+* console.log(Array.from(lines)) // ["hello", "world"]
+* ```
+*
+* @category splitting
+* @since 2.0.0
+*/
+const linesIterator = (self) => linesSeparated(self, true);
+var LinesIterator = class LinesIterator {
+	index;
+	length;
+	s;
+	stripped;
+	constructor(s, stripped = false) {
+		this.s = s;
+		this.stripped = stripped;
+		this.index = 0;
+		this.length = s.length;
+	}
+	next() {
+		if (this.done) return {
+			done: true,
+			value: void 0
+		};
+		const start = this.index;
+		while (!this.done && !isLineBreak(this.s[this.index])) this.index = this.index + 1;
+		let end = this.index;
+		if (!this.done) {
+			const char = this.s[this.index];
+			this.index = this.index + 1;
+			if (!this.done && isLineBreak2(char, this.s[this.index])) this.index = this.index + 1;
+			if (!this.stripped) end = this.index;
+		}
+		return {
+			done: false,
+			value: this.s.substring(start, end)
+		};
+	}
+	[Symbol.iterator]() {
+		return new LinesIterator(this.s, this.stripped);
+	}
+	get done() {
+		return this.index >= this.length;
+	}
+};
+/**
+* Checks whether the provided character is a line break character (i.e. either `"\r"`
+* or `"\n"`).
+*/
+const isLineBreak = (char) => {
+	const code = char.charCodeAt(0);
+	return code === CR || code === LF;
+};
+/**
+* Checks whether the provided characters combine to form a carriage return/line-feed
+* (i.e. `"\r\n"`).
+*/
+const isLineBreak2 = (char0, char1) => char0.charCodeAt(0) === CR && char1.charCodeAt(0) === LF;
+const linesSeparated = (self, stripped) => new LinesIterator(self, stripped);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/internal/random.js
 /** @internal */
@@ -19650,7 +19798,7 @@ function transformOptional(f) {
 */
 function withDefault$1(defaultValue) {
 	return new Getter((o) => {
-		const filtered = filter$2(o, isNotUndefined);
+		const filtered = filter$3(o, isNotUndefined);
 		return isSome(filtered) ? succeed$3(filtered) : mapEager(defaultValue, some);
 	});
 }
@@ -20724,7 +20872,7 @@ var Declaration = class Declaration extends Base {
 * @category models
 * @since 4.0.0
 */
-var Null = class extends Base {
+var Null$1 = class extends Base {
 	_tag = "Null";
 	/** @internal */
 	getParser() {
@@ -20735,7 +20883,7 @@ var Null = class extends Base {
 		return "null";
 	}
 };
-const null_ = /*#__PURE__*/ new Null();
+const null_ = /*#__PURE__*/ new Null$1();
 /**
 * AST node matching the `undefined` value.
 *
@@ -22552,7 +22700,7 @@ const badArgument = (options) => new PlatformError(new BadArgument(options));
 * @category combinators
 * @since 2.0.0
 */
-const join$1 = fiberJoin;
+const join$2 = fiberJoin;
 /**
 * Interrupts a fiber, causing it to stop executing and clean up any
 * acquired resources.
@@ -23154,7 +23302,7 @@ const takeAll$2 = (self) => takeN(self, self.length);
 * @category elements
 * @since 4.0.0
 */
-const take$2 = (self) => {
+const take$3 = (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;
@@ -23208,7 +23356,7 @@ const take$2 = (self) => {
 * @category mutations
 * @since 4.0.0
 */
-const filter = (self, f) => {
+const filter$1 = (self, f) => {
 	const array = [];
 	let chunk = self.head;
 	while (chunk) {
@@ -23274,7 +23422,7 @@ const filter = (self, f) => {
 * @category mutations
 * @since 4.0.0
 */
-const remove$3 = (self, value) => filter(self, (v) => v !== value);
+const remove$3 = (self, value) => filter$1(self, (v) => v !== value);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/MutableRef.js
 const TypeId$36 = "~effect/MutableRef";
@@ -23856,7 +24004,7 @@ const unsubscribe = (self) => uninterruptible(withFiber((state) => {
 * @category subscriptions
 * @since 4.0.0
 */
-const take$1 = (self) => suspend$2(() => {
+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;
@@ -24602,7 +24750,7 @@ var BackPressureStrategy = class {
 	onPubSubEmptySpaceUnsafe(pubsub, subscribers) {
 		let keepPolling = true;
 		while (keepPolling && !pubsub.isFull()) {
-			const publisher = take$2(this.publishers);
+			const publisher = take$3(this.publishers);
 			if (publisher === Empty$2) keepPolling = false;
 			else {
 				const [value, deferred] = publisher;
@@ -24641,7 +24789,7 @@ var BackPressureStrategy = class {
 		}
 	}
 	removeUnsafe(deferred) {
-		filter(this.publishers, ([_, d]) => d !== deferred);
+		filter$1(this.publishers, ([_, d]) => d !== deferred);
 	}
 };
 /**
@@ -24714,7 +24862,7 @@ var DroppingStrategy = class {
 const strategyCompletePollersUnsafe = (strategy, pubsub, subscribers, subscription, pollers) => {
 	let keepPolling = true;
 	while (keepPolling && !subscription.isEmpty()) {
-		const poller = take$2(pollers);
+		const poller = take$3(pollers);
 		if (poller === Empty$2) {
 			removeSubscribers(subscribers, subscription, pollers);
 			if (pollers.length === 0) keepPolling = false;
@@ -25063,7 +25211,7 @@ const offer = (self, message) => suspend$3(() => {
 			}
 			return offerRemainingSingle(self, message);
 		case "sliding":
-			take$2(self.messages);
+			take$3(self.messages);
 			append(self.messages, message);
 			return exitTrue;
 	}
@@ -25106,7 +25254,7 @@ const offerUnsafe = (self, message) => {
 	if (self.state._tag !== "Open") return false;
 	else if (self.messages.length >= self.capacity) {
 		if (self.strategy === "sliding") {
-			take$2(self.messages);
+			take$3(self.messages);
 			append(self.messages, message);
 			return true;
 		} else if (self.capacity <= 0 && self.state.takers.size > 0) {
@@ -25469,7 +25617,7 @@ const takeBetween = (self, min, max) => suspend$3(() => takeBetweenUnsafe(self,
 * @category taking
 * @since 2.0.0
 */
-const take = (self) => suspend$3(() => takeUnsafe(self) ?? andThen$1(awaitTake(self), take(self)));
+const take$1 = (self) => suspend$3(() => takeUnsafe(self) ?? andThen$1(awaitTake(self), take$1(self)));
 /**
 * Attempts to take one message from the queue synchronously.
 *
@@ -25511,14 +25659,14 @@ const take = (self) => suspend$3(() => takeUnsafe(self) ?? andThen$1(awaitTake(s
 const takeUnsafe = (self) => {
 	if (self.state._tag === "Done") return self.state.exit;
 	if (self.messages.length > 0) {
-		const message = take$2(self.messages);
+		const message = take$3(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$2(self.messages);
+		const message = take$3(self.messages);
 		releaseCapacity(self);
 		return exitSucceed(message);
 	}
@@ -25590,7 +25738,7 @@ const takeBetweenUnsafe = (self, min, max) => {
 		self.capacity = 1;
 		releaseCapacity(self);
 		self.capacity = 0;
-		const messages = [take$2(self.messages)];
+		const messages = [take$3(self.messages)];
 		releaseCapacity(self);
 		return exitSucceed(messages);
 	}
@@ -26749,7 +26897,7 @@ const mapEffectConcurrent = (self, f, options) => fromTransformBracket(fnUntrace
 	} else {
 		const effects = yield* bounded(concurrencyN - 2);
 		yield* addFinalizer$1(forkedScope, shutdown(queue));
-		yield* take(effects).pipe(flatten$1, flatMap$2((value) => offer(queue, value)), forever({ disableYield: true }), catchCause$1((cause) => failCause$1(queue, cause)), forkIn(forkedScope));
+		yield* take$1(effects).pipe(flatten$1, flatMap$2((value) => offer(queue, value)), forever({ disableYield: true }), catchCause$1((cause) => failCause$1(queue, cause)), forkIn(forkedScope));
 		let errorCause;
 		const onExit = (exit) => {
 			if (exit._tag === "Success") return;
@@ -26761,10 +26909,10 @@ const mapEffectConcurrent = (self, f, options) => fromTransformBracket(fnUntrace
 			const fiber = runFork(f(value, i++));
 			trackFiber(fiber);
 			fiber.addObserver(onExit);
-			return offer(effects, join$1(fiber));
+			return offer(effects, join$2(fiber));
 		}), forever({ disableYield: true }), catchCause$1((cause) => offer(effects, failCause$3(cause)).pipe(andThen(failCause$1(effects, cause)))), forkIn(forkedScope));
 	}
-	return take(queue);
+	return take$1(queue);
 }));
 /**
 * Maps each output element to a channel and flattens the child channel
@@ -26874,6 +27022,47 @@ const flattenArray = (self) => transformPull$1(self, (pull) => {
 	}));
 });
 /**
+* Filters arrays of elements emitted by a channel, applying the filter
+* to each element within the arrays and only emitting non-empty filtered arrays.
+*
+* **Example** (Filtering array output)
+*
+* ```ts
+* import { Array, Channel } from "effect"
+*
+* const nonEmptyArrayPredicate = Array.isReadonlyArrayNonEmpty
+*
+* // Create a channel that outputs arrays of mixed data
+* const arrayChannel = Channel.fromIterable([
+*   Array.make(1, 2, 3, 4, 5),
+*   Array.make(6, 7, 8, 9, 10),
+*   Array.make(11, 12, 13, 14, 15)
+* ]).pipe(Channel.filter(nonEmptyArrayPredicate))
+*
+* // Filter arrays to keep only even numbers
+* const evenArraysChannel = Channel.filterArray(arrayChannel, (n) => n % 2 === 0)
+* // Outputs: [2, 4], [6, 8, 10], [12, 14]
+* // Note: Only non-empty filtered arrays are emitted
+*
+* // Arrays that would become empty after filtering are discarded entirely
+* const oddChannel = Channel.fromIterable([
+*   Array.make(1, 3, 5),
+*   Array.make(2, 4),
+*   Array.make(7, 9)
+* ]).pipe(Channel.filter(nonEmptyArrayPredicate))
+* const filteredOddChannel = Channel.filterArray(oddChannel, (n) => n % 2 === 0)
+* // Outputs: [2, 4] (the arrays [1,3,5] and [7,9] are discarded)
+* ```
+*
+* @category filtering
+* @since 4.0.0
+*/
+const filterArray = /*#__PURE__*/ dual(2, (self, predicate) => transformPull$1(self, (pull) => succeed$3(flatMap$2(pull, function loop(arr) {
+	const passes = [];
+	for (let i = 0; i < arr.length; i++) if (predicate(arr[i])) passes.push(arr[i]);
+	return isReadonlyArrayNonEmpty(passes) ? succeed$3(passes) : flatMap$2(pull, loop);
+}))));
+/**
 * Catches any cause of failure from the channel and allows recovery by
 * creating a new channel based on the caught cause.
 *
@@ -27042,7 +27231,7 @@ const mergeAll = /*#__PURE__*/ dual(2, (channels, { bufferSize = 16, concurrency
 			fibers.add(fiber);
 		}
 	}).pipe(catchCause$1((cause) => doneLatch.whenOpen(failCause$1(queue, cause))), forkIn(forkedScope));
-	return take(queue);
+	return take$1(queue);
 })));
 /**
 * Returns a new channel, which is the merge of this channel and the specified
@@ -27091,7 +27280,7 @@ const merge$2 = /*#__PURE__*/ dual((args) => isChannel(args[0]) && isChannel(arg
 	const runSide = (side, channel, scope) => toTransform(channel)(upstream, scope).pipe(flatMap$2((pull) => pull.pipe(flatMap$2((value) => offer(queue, value)), forever)), onError((cause) => andThen(close(scope, doneExitFromCause(cause)), onExit(side, cause))), forkIn(forkedScope));
 	yield* runSide("left", left, forkUnsafe(forkedScope));
 	yield* runSide("right", right, forkUnsafe(forkedScope));
-	return take(queue);
+	return take$1(queue);
 })));
 /**
 * Splits upstream string chunks into lines, recognizing `\n`, `\r\n`, and
@@ -27331,6 +27520,35 @@ const runWith = (self, f, onHalt) => suspend$2(() => {
 */
 const provideContext$1 = /*#__PURE__*/ dual(2, (self, context) => fromTransform$1((upstream, scope) => map$4(provideContext$2(toTransform(self)(upstream, scope), context), provideContext$2(context))));
 /**
+* Runs a channel and discards all output elements, returning only the final result.
+*
+* **Example** (Draining channel output at runtime)
+*
+* ```ts
+* import { Channel, Data } from "effect"
+*
+* class DrainError extends Data.TaggedError("DrainError")<{
+*   readonly stage: string
+* }> {}
+*
+* // Create a channel that outputs elements and completes with a result
+* const resultChannel = Channel.fromIterable([1, 2, 3])
+* const completedChannel = Channel.concatWith(
+*   resultChannel,
+*   () => Channel.succeed("completed")
+* )
+*
+* // Drain all elements and get only the final result
+* const drainEffect = Channel.runDrain(completedChannel)
+*
+* // Effect.runSync(drainEffect) // Returns: "completed"
+* ```
+*
+* @category execution
+* @since 2.0.0
+*/
+const runDrain$1 = (self) => runWith(self, (pull) => forever(pull, { disableYield: true }));
+/**
 * Runs a channel and applies an effect to each output element.
 *
 * **Example** (Running effects for each output)
@@ -29155,6 +29373,30 @@ const concat = /*#__PURE__*/ dual(2, (self, that) => flatten(fromArray([self, th
 * @since 2.0.0
 */
 const merge$1 = /*#__PURE__*/ dual((args) => isStream(args[0]) && isStream(args[1]), (self, that, options) => fromChannel(merge$2(toChannel(self), toChannel(that), options)));
+/**
+* Filters a stream to the elements that satisfy a predicate.
+*
+* **Example** (Filtering stream values)
+*
+* ```ts
+* import { Console, Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const stream = Stream.make(1, 2, 3, 4).pipe(
+*     Stream.filter((n) => n % 2 === 0)
+*   )
+*   const values = yield* Stream.runCollect(stream)
+*   yield* Console.log(values)
+* })
+*
+* Effect.runPromise(program)
+* // Output: [ 2, 4 ]
+* ```
+*
+* @category filtering
+* @since 2.0.0
+*/
+const filter = /*#__PURE__*/ dual(2, (self, predicate) => fromChannel(filterArray(toChannel(self), predicate)));
 const catch_ = /*#__PURE__*/ dual(2, (self, f) => fromChannel(catch_$1(self.channel, (error) => f(error).channel)));
 /**
 * Turns typed failures into defects, making the stream infallible.
@@ -29182,6 +29424,77 @@ const catch_ = /*#__PURE__*/ dual(2, (self, f) => fromChannel(catch_$1(self.chan
 */
 const orDie = (self) => fromChannel(orDie$1(self.channel));
 /**
+* Takes the first `n` elements from this stream, returning `Stream.empty` when `n < 1`.
+*
+* **Example** (Taking values from the left)
+*
+* ```ts
+* import { Console, Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const values = yield* Stream.make(1, 2, 3, 4, 5).pipe(
+*     Stream.take(3),
+*     Stream.runCollect
+*   )
+*   yield* Console.log(values)
+* })
+*
+* Effect.runPromise(program)
+* // Output: [ 1, 2, 3 ]
+* ```
+*
+* @category filtering
+* @since 2.0.0
+*/
+const take = /*#__PURE__*/ dual(2, (self, n) => n < 1 ? empty$6 : takeUntil(self, (_, i) => i === n - 1));
+/**
+* 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)
@@ -29589,6 +29902,32 @@ const runForEach = /*#__PURE__*/ dual(2, (self, f) => runForEach$1(self.channel,
 */
 const runForEachArray = /*#__PURE__*/ dual(2, (self, f) => runForEach$1(self.channel, f));
 /**
+* Runs the stream for its effects, discarding emitted elements.
+*
+* **Example** (Draining a stream run)
+*
+* ```ts
+* import { Console, Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const stream = Stream.make(1, 2, 3).pipe(
+*     Stream.mapEffect((n) => Console.log(`Processing: ${n}`))
+*   )
+*
+*   yield* Stream.runDrain(stream)
+* })
+*
+* Effect.runPromise(program)
+* // Processing: 1
+* // Processing: 2
+* // Processing: 3
+* ```
+*
+* @category destructors
+* @since 2.0.0
+*/
+const runDrain = (self) => runDrain$1(self.channel);
+/**
 * Concatenates all emitted strings into a single string.
 *
 * **Example** (Joining strings from a stream)
@@ -31295,7 +31634,7 @@ const set$2 = /*#__PURE__*/ dual(2, (self, value) => sync(() => set$4(self.ref,
 * @category setters
 * @since 2.0.0
 */
-const update = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
+const update$1 = /*#__PURE__*/ dual(2, (self, f) => sync(() => {
 	self.ref.current = f(self.ref.current);
 }));
 /**
@@ -31551,6 +31890,29 @@ function decodeUnknownEffect$1(schema, options) {
 	return options === void 0 ? parser : (input, overrideOptions) => parser(input, mergeParseOptions(options, overrideOptions));
 }
 /**
+* Creates a synchronous decoder for `unknown` input.
+*
+* **When to use**
+*
+* Use to decode untrusted or dynamically typed input at a synchronous boundary
+* where invalid data should be reported by throwing.
+*
+* **Details**
+*
+* The returned function returns the decoded `Type` on success and throws an
+* `Error` with the `SchemaIssue.Issue` in its `cause` on decoding failure.
+*
+* @see {@link decodeSync} for input already typed as the schema's `Encoded` type
+* @see {@link decodeUnknownEffect} for preserving decoding failures in `Effect`
+* @see {@link decodeUnknownResult} for returning schema issues as data
+*
+* @category decoding
+* @since 3.10.0
+*/
+function decodeUnknownSync$1(schema, options) {
+	return asSync(decodeUnknownEffect$1(schema, options));
+}
+/**
 * Creates an effectful encoder for `unknown` input.
 *
 * **When to use**
@@ -31906,6 +32268,44 @@ function decodeUnknownEffect(schema, options) {
 	};
 }
 /**
+* Decodes an `unknown` input against a schema synchronously, returning the
+* decoded value or throwing an `Error` whose cause contains the schema issue.
+*
+* **When to use**
+*
+* Use when validating unknown data at a boundary and treating schema mismatches
+* as exceptions.
+*
+* **Details**
+*
+* For typed input use `decodeSync`.
+* Only service-free schemas can be decoded synchronously. For non-throwing
+* alternatives see `decodeUnknownOption`, `decodeUnknownExit`, or
+* `decodeUnknownEffect`. Options may be provided either when creating the
+* decoder or when applying it; application options override creation options.
+*
+* **Example** (Decoding with a transformation schema)
+*
+* ```ts
+* import { Schema } from "effect"
+*
+* const NumberFromString = Schema.NumberFromString
+*
+* console.log(Schema.decodeUnknownSync(NumberFromString)("42"))
+* // Output: 42
+*
+* Schema.decodeUnknownSync(NumberFromString)("not a number")
+* // throws SchemaError: NumberFromString
+* //   └─ Encoded side transformation failure
+* //      └─ NumberFromString
+* //         └─ Expected a numeric string, actual "not a number"
+* ```
+*
+* @category decoding
+* @since 4.0.0
+*/
+const decodeUnknownSync = decodeUnknownSync$1;
+/**
 * Encodes an `unknown` input against a schema, returning an `Effect` that
 * succeeds with the encoded value or fails with a {@link SchemaError}.
 *
@@ -32093,6 +32493,14 @@ const Any = /*#__PURE__*/ make$34(any);
 */
 const Unknown = /*#__PURE__*/ make$34(unknown);
 /**
+* Schema for the `null` literal. Validates that the input is strictly `null`.
+*
+* @see {@link NullOr} for a union with another schema.
+* @category schemas
+* @since 3.10.0
+*/
+const Null = /*#__PURE__*/ make$34(null_);
+/**
 * Schema for the `undefined` literal. Validates that the input is strictly `undefined`.
 *
 * @see {@link UndefinedOr} for a union with another schema.
@@ -32270,6 +32678,13 @@ function Literals(literals) {
 	});
 }
 /**
+* Creates a union schema of `S | null`.
+*
+* @category constructors
+* @since 3.10.0
+*/
+const NullOr = /*#__PURE__*/ lambda((self) => Union([self, Null]));
+/**
 * Creates a union schema of `S | undefined`.
 *
 * @category constructors
@@ -36698,7 +37113,7 @@ const runtime = (self) => () => map$4(context$1(), (services) => {
 * @category combinators
 * @since 2.0.0
 */
-const join = (self) => _await(self.deferred);
+const join$1 = (self) => _await(self.deferred);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/unstable/socket/Socket.js
 /**
@@ -36984,13 +37399,13 @@ const fromWebSocket = (acquire, options) => withFiber((fiber) => {
 					kind: "Timeout",
 					cause: /* @__PURE__ */ new Error("timeout waiting for \"open\"")
 				}) }))
-			}), raceFirst(join(fiberSet)));
+			}), raceFirst(join$1(fiberSet)));
 		}
 		open = true;
 		currentWS = ws;
 		latch.openUnsafe();
 		if (opts?.onOpen) yield* opts.onOpen;
-		return yield* catchFilter(join(fiberSet), SocketCloseError.filterClean((_) => !closeCodeIsError(_)), () => void_$1);
+		return yield* catchFilter(join$1(fiberSet), SocketCloseError.filterClean((_) => !closeCodeIsError(_)), () => void_$1);
 	})).pipe(updateContext((input) => merge$3(acquireContext, input)), ensuring$2(sync(() => {
 		latch.closeUnsafe();
 		currentWS = void 0;
@@ -42406,7 +42821,7 @@ const make$15 = /*#__PURE__*/ fnUntraced(function* (group, options) {
 	}).pipe(provide$3(scope));
 	yield* forkChild(whileLoop({
 		while: constTrue,
-		body: constant(flatMap$2(take(disconnects), (clientId) => {
+		body: constant(flatMap$2(take$1(disconnects), (clientId) => {
 			clients.delete(clientId);
 			return server.disconnect(clientId);
 		})),
@@ -47659,7 +48074,7 @@ const readDirectory = (path, options) => tryPromise({
 	try: () => NFS.promises.readdir(path, options),
 	catch: (err) => handleErrnoException("FileSystem", "readDirectory")(err, [path])
 });
-const readFile = (path) => callback$1((resume, signal) => {
+const readFile$1 = (path) => callback$1((resume, signal) => {
 	try {
 		NFS.readFile(path, { signal }, (err, data) => {
 			if (err) resume(fail$3(handleErrnoException("FileSystem", "readFile")(err, [path])));
@@ -47780,7 +48195,7 @@ const makeFileSystem = /*#__PURE__*/ map$4(/*#__PURE__*/ serviceOption(WatchBack
 	makeTempFileScoped,
 	open,
 	readDirectory,
-	readFile,
+	readFile: readFile$1,
 	readLink,
 	realPath,
 	remove,
@@ -50026,6 +50441,29 @@ const setUnsafe = (self, value) => {
 */
 const set = /*#__PURE__*/ dual(2, (self, value) => self.semaphore.withPermit(sync(() => setUnsafe(self, value))));
 /**
+* Updates the value of the `SubscriptionRef` with the result of applying a
+* function, notifying subscribers of the change.
+*
+* **Example** (Updating a value)
+*
+* ```ts
+* import { Effect, SubscriptionRef } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const ref = yield* SubscriptionRef.make(10)
+*
+*   yield* SubscriptionRef.update(ref, (n) => n * 2)
+*
+*   const value = yield* SubscriptionRef.get(ref)
+*   console.log(value)
+* })
+* ```
+*
+* @category updating
+* @since 2.0.0
+*/
+const update = /*#__PURE__*/ dual(2, (self, update) => self.semaphore.withPermit(sync(() => setUnsafe(self, update(self.value)))));
+/**
 * Applies an update function to the current value. If it returns
 * `Option.some`, sets and publishes that value; if it returns `Option.none`,
 * leaves the reference unchanged and does not publish.
@@ -50442,9 +50880,100 @@ const TerminalEvent = Union([
 	}),
 	Struct({ type: Literal("reset") })
 ]);
+const TerminalStatus = Union([
+	Struct({ state: Literal("starting") }),
+	Struct({
+		pid: Number$1,
+		state: Literal("running")
+	}),
+	Struct({ state: Literal("stopped") }),
+	Struct({
+		exitCode: Number$1,
+		signal: optional(Number$1),
+		state: Literal("exited")
+	}),
+	Struct({
+		exitCode: optional(Number$1),
+		signal: optional(Number$1),
+		state: Literal("failed")
+	})
+]);
+const TerminalSignals = Struct({
+	activity: Union([
+		Literal("idle"),
+		Literal("starting"),
+		Literal("working"),
+		Literal("thinking"),
+		Literal("waiting"),
+		Literal("needs_input"),
+		Literal("unknown")
+	]),
+	displayTitle: NullOr(String$1),
+	notification: NullOr(Struct({
+		message: NullOr(String$1),
+		sequence: Number$1
+	})),
+	title: NullOr(String$1)
+});
+const TerminalState = Struct({
+	args: ArraySchema(String$1),
+	command: String$1,
+	cwd: String$1,
+	ports: ArraySchema(Number$1),
+	runId: Number$1,
+	signals: TerminalSignals,
+	size: Struct({
+		cols: Number$1,
+		rows: Number$1
+	}),
+	status: TerminalStatus
+});
 //#endregion
 //#region src/rpcs/contracts.ts
-var RpcContracts = class extends make$14(make$17("projects.watch", {
+const TerminalPayload = Struct({
+	args: optional(ArraySchema(String$1)),
+	command: optional(String$1),
+	cwd: String$1,
+	sessionId: optional(String$1)
+});
+const AgentSession = Struct({
+	args: ArraySchema(String$1),
+	command: String$1,
+	cwd: String$1,
+	icon: Literals([
+		"opencode",
+		"codex",
+		"pi"
+	]),
+	label: String$1,
+	uuid: String$1
+});
+var RpcContracts = class extends make$14(make$17("agents.create", {
+	error: TerminalError,
+	payload: Struct({
+		args: ArraySchema(String$1),
+		command: String$1,
+		cwd: String$1,
+		icon: Literals([
+			"opencode",
+			"codex",
+			"pi"
+		]),
+		label: String$1
+	}),
+	success: AgentSession
+}), make$17("agents.remove", {
+	error: TerminalError,
+	payload: Struct({
+		cwd: String$1,
+		uuid: String$1
+	})
+}), make$17("agents.watch", {
+	error: TerminalError,
+	payload: Struct({ cwd: String$1 }),
+	stream: true,
+	success: ArraySchema(AgentSession)
+}), make$17("projects.watch", {
 	stream: true,
 	success: ArraySchema(GitProject)
 }), make$17("projects.branches", {
@@ -50525,16 +51054,27 @@ var RpcContracts = class extends make$14(make$17("projects.watch", {
 		cwd: String$1,
 		force: Boolean$1
 	})
-}), make$17("terminal.events", {
+}), make$17("runs.scripts", {
 	error: TerminalError,
 	payload: Struct({ cwd: String$1 }),
+	success: ArraySchema(Struct({
+		command: String$1,
+		name: String$1,
+		tasks: ArraySchema(String$1)
+	}))
+}), make$17("terminal.events", {
+	error: TerminalError,
+	payload: TerminalPayload,
 	stream: true,
 	success: TerminalEvent
 }), make$17("terminal.input", {
 	error: TerminalError,
 	payload: Struct({
+		args: optional(ArraySchema(String$1)),
+		command: optional(String$1),
 		cwd: String$1,
-		data: String$1
+		data: String$1,
+		sessionId: optional(String$1)
 	})
 }), make$17("terminal.killPort", {
 	error: TerminalError,
@@ -50550,10 +51090,30 @@ var RpcContracts = class extends make$14(make$17("projects.watch", {
 }), make$17("terminal.resize", {
 	error: TerminalError,
 	payload: Struct({
+		args: optional(ArraySchema(String$1)),
 		cols: Number$1,
+		command: optional(String$1),
 		cwd: String$1,
-		rows: Number$1
+		rows: Number$1,
+		sessionId: optional(String$1)
 	})
+}), make$17("terminal.restart", {
+	error: TerminalError,
+	payload: TerminalPayload,
+	success: TerminalState
+}), make$17("terminal.state", {
+	error: TerminalError,
+	payload: TerminalPayload,
+	stream: true,
+	success: TerminalState
+}), make$17("terminal.status", {
+	error: TerminalError,
+	payload: TerminalPayload,
+	stream: true,
+	success: TerminalStatus
+}), make$17("terminal.stop", {
+	error: TerminalError,
+	payload: TerminalPayload
 })) {};
 //#endregion
 //#region ../../packages/git/src/service.ts
@@ -50622,7 +51182,7 @@ var GitWorkspace = class extends Service()("@deslop/git/service/GitWorkspace", {
 					gitDirectory,
 					root: roots[0]
 				}))), orElseSucceed(() => failVoid), flatMap$2((repository) => collectRepositoriesFromRoots(drop$1(roots, 1), append$1(repositories, repository))));
-				return pipe(entries, filter$1((entry) => !(new Set([
+				return pipe(entries, filter$2((entry) => !(new Set([
 					".git",
 					".next",
 					".turbo",
@@ -50630,7 +51190,7 @@ var GitWorkspace = class extends Service()("@deslop/git/service/GitWorkspace", {
 					"coverage",
 					"dist",
 					"node_modules"
-				]).has(entry) || startsWith(".")(entry) && entry !== ".git")), forEach$1((entry) => pipe(fs.stat(path.join(roots[0], entry)), map$4((info) => info.type === "Directory" ? path.join(roots[0], entry) : ""), orElseSucceed(() => ""))), flatMap$2((nextRoots) => collectRepositoriesFromRoots(pipe(nextRoots, filter$1(isNonEmpty$1), appendAll(drop$1(roots, 1))), repositories)));
+				]).has(entry) || startsWith(".")(entry) && entry !== ".git")), forEach$1((entry) => pipe(fs.stat(path.join(roots[0], entry)), map$4((info) => info.type === "Directory" ? path.join(roots[0], entry) : ""), orElseSucceed(() => ""))), flatMap$2((nextRoots) => collectRepositoriesFromRoots(pipe(nextRoots, filter$2(isNonEmpty$1), appendAll(drop$1(roots, 1))), repositories)));
 			}))
 		});
 	});
@@ -50707,11 +51267,11 @@ var GitWorkspace = class extends Service()("@deslop/git/service/GitWorkspace", {
 					"for-each-ref",
 					"--format=%(refname:short)",
 					"refs/remotes"
-				]), map$4((lines) => pipe(lines, filter$1((name) => !endsWith("/HEAD")(name)), map$7((name) => new GitBranch({
-					name: pipe(split$1("/")(name), drop$1(1), join$2("/")),
+				]), map$4((lines) => pipe(lines, filter$2((name) => !endsWith("/HEAD")(name)), map$7((name) => new GitBranch({
+					name: pipe(split$1("/")(name), drop$1(1), join$3("/")),
 					remote: split$1("/")(name)[0],
 					type: "remote"
-				})), filter$1((branch) => isNonEmpty$1(branch.name)), appendAll(localBranches)))))),
+				})), filter$2((branch) => isNonEmpty$1(branch.name)), appendAll(localBranches)))))),
 				defaultBranch: yield* getDefaultBranch(cwd)
 			});
 		}),
@@ -50863,7 +51423,7 @@ var GitWorktree = class extends Service()("@deslop/git/service/GitWorktree", { m
 			"--exclude-standard"
 		]), (filePath) => pipe(fs.readFileString(path.join(config.cwd, filePath)), orElseSucceed(() => ""), map$4((content) => new GitDiff({
 			filePath,
-			patch: `diff --git a/${filePath} b/${filePath}\nnew file mode 100644\n--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${length(split$1("\n")(content))} @@\n${pipe(split$1("\n")(content), map$7((line) => `+${line}`), join$2("\n"))}`,
+			patch: `diff --git a/${filePath} b/${filePath}\nnew file mode 100644\n--- /dev/null\n+++ b/${filePath}\n@@ -0,0 +1,${length(split$1("\n")(content))} @@\n${pipe(split$1("\n")(content), map$7((line) => `+${line}`), join$3("\n"))}`,
 			status: "added"
 		}))), { concurrency: "unbounded" });
 	});
@@ -50962,7 +51522,7 @@ var GitWorktree = class extends Service()("@deslop/git/service/GitWorktree", { m
 			const subject = parts[2] ?? "";
 			return new GitCommit({
 				hash: parts[0] ?? "",
-				parents: pipe(parts[3] ?? "", split$1(" "), filter$1(isNonEmpty$1)),
+				parents: pipe(parts[3] ?? "", split$1(" "), filter$2(isNonEmpty$1)),
 				shortHash: parts[1] ?? "",
 				subject,
 				wip: startsWith("wip: ")(subject)
@@ -50972,7 +51532,7 @@ var GitWorktree = class extends Service()("@deslop/git/service/GitWorktree", { m
 	return {
 		commitAndPush: fnUntraced(function* (input) {
 			if (yield* hasWorktreeChanges) return yield* fail$3(new GitError({ message: "Create a WIP commit before squashing." }));
-			const oldestWip = pipe(yield* commits(input.base), filter$1((commit) => commit.wip), last, getOrUndefined$1);
+			const oldestWip = pipe(yield* commits(input.base), filter$2((commit) => commit.wip), last, getOrUndefined$1);
 			if (!oldestWip) return yield* fail$3(new GitError({ message: "No WIP commits to squash." }));
 			yield* pipe(git.string(config.cwd, [
 				"reset",
@@ -57376,27 +57936,23 @@ var require_xterm_headless = /* @__PURE__ */ __commonJSMin(((exports) => {
 var import_addon_serialize = require_addon_serialize();
 var import_xterm_headless = /* @__PURE__ */ __toESM(require_xterm_headless(), 1);
 function parseProcessParents(output) {
-	const parents = /* @__PURE__ */ new Map();
-	for (const line of output.split("\n")) {
-		const columns = line.trim().split(/\s+/);
-		const pid = Number(columns[0]);
-		const ppid = Number(columns[1]);
-		if (Number.isFinite(pid) && Number.isFinite(ppid)) parents.set(pid, ppid);
-	}
-	return parents;
+	return new Map(pipe(linesIterator(output), fromIterable$2, filterMap((line) => {
+		const columns = split$1(/\s+/)(trim(line));
+		const pid = Number(columns[0] ?? NaN);
+		const ppid = Number(columns[1] ?? NaN);
+		return Number.isFinite(pid) && Number.isFinite(ppid) ? succeed$7([pid, ppid]) : failVoid;
+	})));
 }
 function parseListeningPorts(output) {
-	const ports = [];
-	for (const line of output.split("\n")) {
-		const columns = line.trim().split(/\s+/);
+	return pipe(linesIterator(output), fromIterable$2, filterMap((line) => {
+		const columns = split$1(/\s+/)(trim(line));
 		const port = Number(columns[3]?.match(/:(\d+)$/)?.[1]);
 		const pid = Number(line.match(/pid=(\d+)/)?.[1]);
-		if (Number.isFinite(port) && Number.isFinite(pid)) ports.push({
+		return Number.isFinite(port) && Number.isFinite(pid) ? succeed$7({
 			pid,
 			port
-		});
-	}
-	return ports;
+		}) : failVoid;
+	}));
 }
 function isDescendant(pid, ancestorPid, parents) {
 	let current = pid;
@@ -57410,6 +57966,11 @@ function isDescendant(pid, ancestorPid, parents) {
 	}
 	return false;
 }
+function descendantsOf(ancestorPid, parents) {
+	const descendants = [];
+	for (const pid of parents.keys()) if (pid !== ancestorPid && isDescendant(pid, ancestorPid, parents)) descendants.push(pid);
+	return descendants;
+}
 const commandString = fnUntraced(function* (command, args, message) {
 	return yield* pipe((yield* ChildProcessSpawner.useSync((spawner) => spawner.string))(make$39(command, args)), mapError$2((cause) => new TerminalError({
 		cause,
@@ -57418,46 +57979,196 @@ const commandString = fnUntraced(function* (command, args, message) {
 });
 const readProcessParents = pipe(commandString("ps", ["-eo", "pid=,ppid="], "failed to list terminal processes"), map$4(parseProcessParents));
 const readListeningPorts = pipe(commandString("ss", ["-H", "-ltnp"], "failed to list terminal ports"), map$4(parseListeningPorts));
+const initialSize = {
+	cols: 120,
+	rows: 32
+};
+const initialSignals = {
+	activity: "idle",
+	displayTitle: null,
+	notification: null,
+	title: null
+};
+const scrollback = 1e4;
+const snapshotChunkSize = 64 * 1024;
+function parseTitleSignal(title) {
+	const trimmed = trim(title);
+	if (/^\[\s*[!.]\s*\]\s*Action Required\b/i.test(trimmed)) return {
+		activity: "needs_input",
+		displayTitle: trimmed.replace(/^\[\s*[!.]\s*\]\s*/i, "") || trimmed,
+		title
+	};
+	const displayTitle = trimmed.replace(/^OC\s*\|\s*/i, "").replace(/^π\s*-\s*/i, "").replace(/^\[\s*[^\]]+\s*\]\s*/, "").replace(/^(?:[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏|/\\-]\s*)+/, "").trim() || (trimmed === "" ? null : trimmed);
+	const segment = displayTitle?.match(/^(Starting|Working|Thinking|Waiting|Ready)\b/i)?.[1]?.toLowerCase();
+	if (segment === "starting") return {
+		activity: "starting",
+		displayTitle,
+		title
+	};
+	if (segment === "working") return {
+		activity: "working",
+		displayTitle,
+		title
+	};
+	if (segment === "thinking") return {
+		activity: "thinking",
+		displayTitle,
+		title
+	};
+	if (segment === "waiting") return {
+		activity: "waiting",
+		displayTitle,
+		title
+	};
+	if (segment === "ready") return {
+		activity: "idle",
+		displayTitle,
+		title
+	};
+	if (/^\[\s*[^\]]+\s*\]/.test(trimmed) || /^(?:[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏|/\\-]\s*)+/.test(trimmed)) return {
+		activity: "working",
+		displayTitle,
+		title
+	};
+	return {
+		activity: isNonEmpty$1(trimmed) ? "unknown" : "idle",
+		displayTitle,
+		title
+	};
+}
+function snapshotEvents(data) {
+	if (data === "") return [{
+		data,
+		type: "snapshot"
+	}];
+	const events = [];
+	for (let index = 0; index < data.length; index += snapshotChunkSize) events.push({
+		data: data.slice(index, index + snapshotChunkSize),
+		type: "snapshot"
+	});
+	return events;
+}
 var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { make: fnUntraced(function* (config) {
 	const events = yield* bounded$1({ capacity: 256 });
+	const controls = yield* unbounded();
 	const dataQueue = yield* unbounded();
-	const portsRef = yield* make$3([]);
+	const signalQueue = yield* unbounded();
 	const portOwners = yield* make$37(/* @__PURE__ */ new Map());
 	const processRef = yield* make$37(void 0);
 	const screenLock = yield* make$46(1);
 	const sequenceRef = yield* make$37(0);
-	const sizeRef = yield* make$37({
-		cols: 120,
-		rows: 32
-	});
 	const shell = yield* string("SHELL").pipe(orElseSucceed(() => "bash"));
+	const processCommand = config.command ?? shell;
+	const processArgs = config.args ?? [];
+	const autostart = config.command === void 0;
+	const restartPolicy = config.restart ?? (config.command ? "never" : "always");
+	const stateRef = yield* make$3({
+		args: [...processArgs],
+		command: processCommand,
+		cwd: config.cwd,
+		ports: [],
+		runId: 0,
+		signals: initialSignals,
+		size: initialSize,
+		status: autostart ? { state: "starting" } : { state: "stopped" }
+	});
 	const screen = new import_xterm_headless.default.Terminal({
 		allowProposedApi: true,
-		cols: 120,
-		rows: 32,
-		scrollback: 1e4
+		cols: initialSize.cols,
+		rows: initialSize.rows,
+		scrollback
 	});
 	const serialize = new import_addon_serialize.SerializeAddon();
 	screen.loadAddon(serialize);
-	function publish$1(event) {
-		return pipe(updateAndGet(sequenceRef, (sequence) => sequence + 1), flatMap$2((sequence) => publish(events, {
+	screen.onTitleChange((title) => {
+		offerUnsafe(signalQueue, {
+			title,
+			type: "title"
+		});
+	});
+	screen.onBell(() => {
+		offerUnsafe(signalQueue, {
+			message: null,
+			type: "notification"
+		});
+	});
+	screen.parser.registerOscHandler(9, (data) => {
+		const [kind, value] = split$1(";")(data);
+		if (kind === "4") {
+			offerUnsafe(signalQueue, {
+				activity: value === "0" ? "idle" : "working",
+				type: "activity"
+			});
+			return true;
+		}
+		offerUnsafe(signalQueue, {
+			message: data,
+			type: "notification"
+		});
+		return true;
+	});
+	const publish$1 = fnUntraced(function* (event) {
+		return yield* pipe(updateAndGet(sequenceRef, (sequence) => sequence + 1), flatMap$2((sequence) => publish(events, {
 			event,
 			sequence
 		})), asVoid);
-	}
+	});
 	const requestSnapshot = withPermit(screenLock, gen(function* () {
 		return {
-			data: serialize.serialize({ scrollback: 1e4 }),
+			data: serialize.serialize({ scrollback }),
 			sequence: yield* get$1(sequenceRef)
 		};
 	}));
-	function resetScreen() {
-		return withPermit(screenLock, pipe(sync(() => {
-			screen.reset();
-		}), andThen(publish$1({ type: "reset" }))));
+	function setStatus(status) {
+		return update(stateRef, (state) => ({
+			...state,
+			status
+		}));
+	}
+	const resetSignals = update(stateRef, (state) => ({
+		...state,
+		signals: initialSignals
+	}));
+	const startRun = gen(function* () {
+		yield* update(stateRef, (state) => ({
+			...state,
+			ports: [],
+			runId: state.runId + 1,
+			signals: initialSignals,
+			status: { state: "starting" }
+		}));
+		return yield* get(stateRef);
+	});
+	function setPorts(ports) {
+		return updateSome(stateRef, (state) => state.ports.length === ports.length && state.ports.every((port, index) => port === ports[index]) ? none() : some({
+			...state,
+			ports: [...ports]
+		}));
 	}
-	function writeScreen(data) {
-		return withPermit(screenLock, pipe(callback$1((resume) => {
+	const interruptProcessTree = fnUntraced(function* (subprocess, signal) {
+		const descendants = yield* pipe(readProcessParents, map$4((parents) => descendantsOf(subprocess.pid, parents)), timeoutOption("250 millis"), map$4((option) => getOrElse$1(option, () => [])), catch_$2(() => succeed$3([])));
+		yield* sync(() => {
+			try {
+				if (nodeProcess.platform !== "win32") nodeProcess.kill(-subprocess.pid, signal);
+			} catch {}
+			for (const pid of descendants.toReversed()) try {
+				nodeProcess.kill(pid, signal);
+			} catch {}
+			try {
+				subprocess.kill(signal);
+			} catch {}
+		});
+	});
+	const terminateProcess = fnUntraced(function* (subprocess) {
+		yield* interruptProcessTree(subprocess, "SIGTERM");
+		yield* sleep("250 millis");
+		yield* interruptProcessTree(subprocess, "SIGKILL");
+	});
+	const resetScreen = withPermit(screenLock, pipe(sync(() => {
+		screen.reset();
+	}), andThen(publish$1({ type: "reset" }))));
+	const writeScreen = fnUntraced(function* (data) {
+		return yield* withPermit(screenLock, pipe(callback$1((resume) => {
 			screen.write(data, () => {
 				resume(void_$1);
 			});
@@ -57465,26 +58176,54 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 			data,
 			type: "data"
 		}))));
-	}
-	yield* addFinalizer(() => all([shutdown(dataQueue), shutdown$1(events)], { discard: true }));
+	});
+	yield* addFinalizer(() => all([
+		shutdown(controls),
+		shutdown(dataQueue),
+		shutdown(signalQueue),
+		shutdown$1(events)
+	], { discard: true }));
 	yield* pipe(fromQueue(dataQueue), runForEach(writeScreen), forkScoped);
+	yield* pipe(fromQueue(signalQueue), runForEach((signal) => update(stateRef, (state) => {
+		if (signal.type === "activity") {
+			const titleActivity = state.signals.title === null ? "idle" : parseTitleSignal(state.signals.title).activity;
+			if (titleActivity !== "idle" && titleActivity !== "unknown") return state;
+			return {
+				...state,
+				signals: {
+					...state.signals,
+					activity: signal.activity
+				}
+			};
+		}
+		if (signal.type === "title") return {
+			...state,
+			signals: {
+				...state.signals,
+				...parseTitleSignal(signal.title)
+			}
+		};
+		return {
+			...state,
+			signals: {
+				...state.signals,
+				notification: {
+					message: signal.message,
+					sequence: (state.signals.notification?.sequence ?? 0) + 1
+				}
+			}
+		};
+	})), forkScoped);
 	const spawnProcess = acquireRelease(gen(function* () {
-		const size = yield* get$1(sizeRef);
+		const size = (yield* get(stateRef)).size;
 		const exited = yield* make$59();
 		let didExit = false;
-		const nodePty = yield* tryPromise({
-			catch: (cause) => new TerminalError({
-				cause,
-				message: "failed to load terminal process runtime"
-			}),
-			try: () => import("@lydell/node-pty")
-		});
 		const subprocess = yield* try_({
 			catch: (cause) => new TerminalError({
 				cause,
 				message: `failed to spawn terminal in ${config.cwd}`
 			}),
-			try: () => nodePty.spawn(shell, [], {
+			try: () => nodePty.spawn(processCommand, [...processArgs], {
 				cols: size.cols,
 				cwd: config.cwd,
 				env: {
@@ -57498,58 +58237,95 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		const data = subprocess.onData((data) => {
 			offerUnsafe(dataQueue, data);
 		});
-		const exit = subprocess.onExit(() => {
+		const exit = subprocess.onExit((event) => {
 			didExit = true;
-			doneUnsafe(exited, void_$1);
+			doneUnsafe(exited, succeed$3(event));
 		});
 		yield* set$2(processRef, subprocess);
+		yield* setStatus({
+			pid: subprocess.pid,
+			state: "running"
+		});
 		return {
 			data,
+			didExit: () => didExit,
 			exit,
 			exited,
-			kill: () => {
-				if (!didExit) subprocess.kill();
-			},
-			process: subprocess
+			process: subprocess,
+			terminate: terminateProcess(subprocess)
 		};
 	}), (subprocess) => gen(function* () {
 		yield* sync(() => {
 			subprocess.data.dispose();
 			subprocess.exit.dispose();
-			subprocess.kill();
 		});
-		yield* update(processRef, (current) => current === subprocess.process ? void 0 : current);
+		if (!subprocess.didExit()) yield* pipe(subprocess.terminate, ignore$1);
+		yield* update$1(processRef, (current) => current === subprocess.process ? void 0 : current);
 	}));
-	yield* pipe(scoped$3(gen(function* () {
-		yield* _await((yield* spawnProcess).exited);
-	})), ignore$1, andThen(set$2(portOwners, /* @__PURE__ */ new Map())), andThen(updateSome(portsRef, (ports) => ports.length === 0 ? none() : some([]))), andThen(resetScreen()), repeat(spaced("250 millis")), forkScoped);
+	yield* pipe(gen(function* () {
+		let restart = autostart;
+		while (true) {
+			if (!restart) {
+				restart = (yield* take$1(controls)).type === "restart";
+				if (!restart) continue;
+			}
+			yield* resetScreen;
+			yield* resetSignals;
+			yield* setStatus({ state: "starting" });
+			const action = yield* pipe(scoped$3(flatMap$2(spawnProcess, (subprocess) => raceFirst(pipe(_await(subprocess.exited), map$4((event) => ({
+				event,
+				type: "exit"
+			}))), take$1(controls)))), catch_$2((error) => succeed$3({
+				error,
+				type: "error"
+			})));
+			yield* set$2(portOwners, /* @__PURE__ */ new Map());
+			yield* setPorts([]);
+			if (action.type === "stop") {
+				yield* setStatus({ state: "stopped" });
+				restart = (yield* take$1(controls)).type === "restart";
+				if (restart) yield* sleep("250 millis");
+				continue;
+			} else if (action.type === "restart") restart = true;
+			else if (action.type === "error") {
+				yield* setStatus({ state: "failed" });
+				restart = restartPolicy === "always" || restartPolicy === "failed";
+			} else {
+				const failed = action.event.exitCode !== 0;
+				yield* setStatus({
+					exitCode: action.event.exitCode,
+					...action.event.signal === void 0 ? {} : { signal: action.event.signal },
+					state: failed ? "failed" : "exited"
+				});
+				restart = restartPolicy === "always" || restartPolicy === "failed" && failed;
+			}
+			if (restart) yield* sleep("250 millis");
+		}
+	}), forkScoped);
 	yield* pipe(gen(function* () {
 		const process = yield* get$1(processRef);
 		if (!process?.pid) {
 			yield* set$2(portOwners, /* @__PURE__ */ new Map());
-			yield* updateSome(portsRef, (ports) => ports.length === 0 ? none() : some([]));
+			yield* setPorts([]);
 			return;
 		}
 		const [parents, listeningPorts] = yield* all([readProcessParents, readListeningPorts]);
 		const nextPortOwners = /* @__PURE__ */ new Map();
-		const nextPorts = pipe(listeningPorts, filter$1((port) => isDescendant(port.pid, process.pid, parents)), map$7((port) => {
+		const nextPorts = pipe(listeningPorts, filter$2((port) => isDescendant(port.pid, process.pid, parents)), map$7((port) => {
 			nextPortOwners.set(port.port, port.pid);
 			return port.port;
 		}), dedupe, sort(Number$5));
 		yield* set$2(portOwners, nextPortOwners);
-		yield* updateSome(portsRef, (currentPorts) => currentPorts.length === nextPorts.length && currentPorts.every((port, index) => port === nextPorts[index]) ? none() : some(nextPorts));
+		yield* setPorts(nextPorts);
 	}), ignore$1, repeat(spaced("1 second")), forkScoped);
 	return {
 		events: scoped$1(unwrap$1(gen(function* () {
 			const subscription = yield* subscribe(events);
 			const snapshot = yield* requestSnapshot;
 			const initialEvents = (yield* takeUpTo(subscription, Number.POSITIVE_INFINITY)).filter((event) => event.sequence > snapshot.sequence).map((event) => event.event);
-			return pipe(fromIterable$1([{
-				data: snapshot.data,
-				type: "snapshot"
-			}, ...initialEvents]), concat(fromEffectRepeat(take$1(subscription)).pipe(map$2((event) => event.event))));
+			return pipe(fromIterable$1([...snapshotEvents(snapshot.data), ...initialEvents]), concat(fromEffectRepeat(take$2(subscription)).pipe(map$2((event) => event.event))));
 		}))),
-		killPort: (port) => gen(function* () {
+		killPort: fnUntraced(function* (port) {
 			const pid = (yield* get$1(portOwners)).get(port);
 			if (!pid) return;
 			yield* try_({
@@ -57558,15 +58334,17 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 					message: `failed to kill process on port ${port}`
 				}),
 				try: () => {
-					process.kill(pid);
+					nodeProcess.kill(pid);
 				}
 			});
 		}),
-		ports: changes(portsRef),
-		resize: (nextSize) => gen(function* () {
-			const size = yield* get$1(sizeRef);
+		resize: fnUntraced(function* (nextSize) {
+			const size = (yield* get(stateRef)).size;
 			if (size.cols === nextSize.cols && size.rows === nextSize.rows) return;
-			yield* set$2(sizeRef, nextSize);
+			yield* update(stateRef, (state) => ({
+				...state,
+				size: nextSize
+			}));
 			yield* withPermit(screenLock, sync(() => {
 				screen.resize(nextSize.cols, nextSize.rows);
 			}));
@@ -57582,7 +58360,10 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 				}
 			});
 		}),
-		write: (data) => gen(function* () {
+		restart: pipe(startRun, tap(() => offer(controls, { type: "restart" }))),
+		state: stateRef,
+		stop: offer(controls, { type: "stop" }),
+		write: fnUntraced(function* (data) {
 			const process = yield* get$1(processRef);
 			if (!process) return;
 			yield* try_({
@@ -57600,11 +58381,101 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 	static layer = flow(this.make, effect(this));
 };
 //#endregion
+//#region ../../packages/terminal/src/utils.ts
+function splitParallelCommands(script) {
+	const state = pipe(split$1("")(script), reduce({
+		commands: [],
+		current: "",
+		escaped: false,
+		skipNext: false
+	}, (state, char, index) => {
+		if (state.skipNext) return {
+			...state,
+			skipNext: false
+		};
+		if (state.escaped) return {
+			...state,
+			current: state.current + char,
+			escaped: false
+		};
+		if (char === "\\") return {
+			...state,
+			current: state.current + char,
+			escaped: true
+		};
+		if (state.quote) return {
+			...state,
+			current: state.current + char,
+			quote: char === state.quote ? void 0 : state.quote
+		};
+		if (char === "\"" || char === "'") return {
+			...state,
+			current: state.current + char,
+			quote: char
+		};
+		if (char === "&" && script[index + 1] === "&") return {
+			...state,
+			current: `${state.current}&&`,
+			skipNext: true
+		};
+		if (char !== "&") return {
+			...state,
+			current: state.current + char
+		};
+		return pipe(liftPredicate(trim(state.current), isNonEmpty$1), match$4({
+			onNone: () => ({
+				...state,
+				current: ""
+			}),
+			onSome: (command) => ({
+				...state,
+				commands: [...state.commands, command],
+				current: ""
+			})
+		}));
+	}));
+	return pipe(liftPredicate(trim(state.current), isNonEmpty$1), match$4({
+		onNone: () => state.commands,
+		onSome: (command) => [...state.commands, command]
+	}));
+}
+//#endregion
 //#region src/rpcs/handlers.ts
+const TerminalSessionKey = Struct({
+	args: optional(ArraySchema(String$1)),
+	command: optional(String$1),
+	cwd: String$1,
+	sessionId: optional(String$1)
+});
+function terminalSessionKey(input) {
+	return JSON.stringify({
+		args: input.args,
+		command: input.command,
+		cwd: input.cwd,
+		sessionId: input.sessionId
+	});
+}
+function agentSessionId(uuid) {
+	return `agent:${uuid}`;
+}
+function agentSessionKey(input) {
+	return JSON.stringify(input);
+}
 const TerminalSessions = make$45({
 	idleTimeToLive: infinity,
-	lookup: fnUntraced(function* (cwd) {
-		return get$7(yield* buildWithScope(Terminal.layer({ cwd }), yield* scope), Terminal);
+	lookup: fnUntraced(function* (key) {
+		const config = yield* try_({
+			catch: (cause) => new TerminalError({
+				cause,
+				message: "invalid terminal session key"
+			}),
+			try: () => decodeUnknownSync(TerminalSessionKey)(JSON.parse(key))
+		});
+		return get$7(yield* buildWithScope(Terminal.layer({
+			args: config.args,
+			command: config.command,
+			cwd: config.cwd
+		}), yield* scope), Terminal);
 	})
 });
 const GitWorktreeSessions = make$45({
@@ -57617,7 +58488,52 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 	const git = yield* GitWorkspace;
 	const terminals = yield* TerminalSessions;
 	const gitWorktrees = yield* GitWorktreeSessions;
+	const agents = yield* make$3(/* @__PURE__ */ new Map());
 	return RpcContracts.of({
+		"agents.create": (payload) => gen(function* () {
+			const labelCount = pipe(fromIterable$2((yield* get(agents)).values()), filter$2((session) => session.cwd === payload.cwd), filter$2((session) => session.command === payload.command), length);
+			const session = {
+				args: [...payload.args],
+				command: payload.command,
+				cwd: payload.cwd,
+				icon: payload.icon,
+				label: `${payload.label} ${labelCount + 1}`,
+				uuid: randomUUID()
+			};
+			yield* update(agents, (sessions) => {
+				const next = new Map(sessions);
+				next.set(agentSessionKey({
+					cwd: session.cwd,
+					uuid: session.uuid
+				}), session);
+				return next;
+			});
+			const terminal = yield* get$4(terminals, terminalSessionKey({
+				args: session.args,
+				command: session.command,
+				cwd: session.cwd,
+				sessionId: agentSessionId(session.uuid)
+			}));
+			yield* terminal.restart;
+			yield* pipe(pipe(changes(terminal.state), map$2((state) => state.status.state), filter((state) => state === "exited" || state === "failed" || state === "stopped"), take(1), runDrain), andThen(update(agents, (current) => {
+				const next = new Map(current);
+				next.delete(agentSessionKey({
+					cwd: session.cwd,
+					uuid: session.uuid
+				}));
+				return next;
+			})), forkScoped);
+			return session;
+		}),
+		"agents.remove": (payload) => update(agents, (current) => {
+			const next = new Map(current);
+			next.delete(agentSessionKey({
+				cwd: payload.cwd,
+				uuid: payload.uuid
+			}));
+			return next;
+		}),
+		"agents.watch": (payload) => unwrap$1(pipe(get(agents), map$4((current) => pipe(concat(drop(1)(changes(agents)))(make$42(current)), map$2((sessions) => pipe(fromIterable$2(sessions.values()), filter$2((session) => session.cwd === payload.cwd))))))),
 		"projects.branches": (payload) => git.branches(payload.cwd),
 		"projects.createWorktree": (payload) => git.createWorktree(payload),
 		"projects.deleteWorktree": (payload) => git.deleteWorktree(payload),
@@ -57636,14 +58552,29 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 			from: payload.from,
 			to: payload.to
 		})))),
-		"terminal.events": (payload) => unwrap$1(pipe(get$4(terminals, payload.cwd), map$4((terminal) => terminal.events))),
-		"terminal.input": (payload) => pipe(get$4(terminals, payload.cwd), flatMap$2((terminal) => terminal.write(payload.data)), asVoid),
-		"terminal.killPort": (payload) => pipe(get$4(terminals, payload.cwd), flatMap$2((terminal) => terminal.killPort(payload.port))),
-		"terminal.ports": (payload) => unwrap$1(pipe(get$4(terminals, payload.cwd), map$4((terminal) => terminal.ports))),
-		"terminal.resize": (payload) => pipe(get$4(terminals, payload.cwd), flatMap$2((terminal) => terminal.resize({
+		"runs.scripts": (payload) => pipe(tryPromise({
+			catch: (cause) => new TerminalError({
+				cause,
+				message: `failed to read package.json in ${payload.cwd}`
+			}),
+			try: () => readFile(join(payload.cwd, "package.json"), "utf8")
+		}), map$4((content) => JSON.parse(content)), map$4((packageJson) => Object.entries(packageJson.scripts ?? {}).map(([name, command]) => ({
+			command,
+			name,
+			tasks: splitParallelCommands(command)
+		})))),
+		"terminal.events": (payload) => unwrap$1(pipe(get$4(terminals, terminalSessionKey(payload)), map$4((terminal) => terminal.events))),
+		"terminal.input": (payload) => pipe(get$4(terminals, terminalSessionKey(payload)), flatMap$2((terminal) => terminal.write(payload.data)), asVoid),
+		"terminal.killPort": (payload) => pipe(get$4(terminals, terminalSessionKey({ cwd: payload.cwd })), flatMap$2((terminal) => terminal.killPort(payload.port))),
+		"terminal.ports": (payload) => unwrap$1(pipe(get$4(terminals, terminalSessionKey(payload)), map$4((terminal) => pipe(changes(terminal.state), map$2((state) => state.ports))))),
+		"terminal.resize": (payload) => pipe(get$4(terminals, terminalSessionKey(payload)), flatMap$2((terminal) => terminal.resize({
 			cols: payload.cols,
 			rows: payload.rows
-		})))
+		}))),
+		"terminal.restart": (payload) => pipe(get$4(terminals, terminalSessionKey(payload)), flatMap$2((terminal) => terminal.restart)),
+		"terminal.state": (payload) => unwrap$1(pipe(get$4(terminals, terminalSessionKey(payload)), map$4((terminal) => changes(terminal.state)))),
+		"terminal.status": (payload) => unwrap$1(pipe(get$4(terminals, terminalSessionKey(payload)), map$4((terminal) => pipe(changes(terminal.state), map$2((state) => state.status))))),
+		"terminal.stop": (payload) => pipe(get$4(terminals, terminalSessionKey(payload)), flatMap$2((terminal) => terminal.stop), asVoid)
 	});
 }));
 //#endregion
@@ -74527,13 +75458,16 @@ function BrowserProxyMiddleware(app) {
 //#endregion
 //#region src/main.server.ts
 runMain(pipe(serve(mergeAll$1(layerHttp({
-	group: make$14().merge(RpcContracts),
+	group: RpcContracts,
 	path: "/api/rpc",
 	protocol: "websocket"
 }), layer$4({
 	index: "index.html",
 	root: fileURLToPath(new URL("./client", import.meta.url)),
 	spa: true
-}), middleware(BrowserProxyMiddleware, { global: true }), middleware(xForwardedHeaders, { global: true })), { disableLogger: true }), provide$2(LiveLayers), provide$2(layerConfig(createServer, { port: port("PORT").pipe(withDefault(4010)) })), provide$2(layer$6), launch));
+}), middleware(BrowserProxyMiddleware, { global: true }), middleware(xForwardedHeaders, { global: true })), { disableLogger: true }), provide$2(LiveLayers), provide$2(layerConfig(createServer, {
+	gracefulShutdownTimeout: succeed("1500 millis"),
+	port: port("PORT").pipe(withDefault(4010))
+})), provide$2(layer$6), launch));
 //#endregion
 export { __toCommonJS as a, __require as i, init_esm$2 as n, __commonJSMin as r, esm_exports$2 as t };