@deslop/workbench 0.0.320 → 0.0.327

package/dist/server.js

@@ -21,6 +21,8 @@ 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;
@@ -4499,9 +4501,9 @@ const isArrayNonEmpty$1 = (self) => self.length > 0;
 /**
 * @since 2.0.0
 */
-const TypeId$50 = "~effect/data/Option";
+const TypeId$52 = "~effect/data/Option";
 const CommonProto$1 = {
-	[TypeId$50]: { _A: (_) => _ },
+	[TypeId$52]: { _A: (_) => _ },
 	...PipeInspectableProto,
 	[Symbol.iterator]() {
 		return new SingleShotGen(this);
@@ -4552,7 +4554,7 @@ const NoneProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(Common
 	}
 });
 /** @internal */
-const isOption = (input) => hasProperty(input, TypeId$50);
+const isOption = (input) => hasProperty(input, TypeId$52);
 /** @internal */
 const isNone$1 = (fa) => fa._tag === "None";
 /** @internal */
@@ -4567,9 +4569,9 @@ const some$2 = (value) => {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/internal/result.js
-const TypeId$49 = "~effect/data/Result";
+const TypeId$51 = "~effect/data/Result";
 const CommonProto = {
-	[TypeId$49]: {
+	[TypeId$51]: {
 		/* v8 ignore next 2 */
 		_A: (_) => _,
 		_E: (_) => _
@@ -4583,7 +4585,7 @@ const SuccessProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(Com
 	_tag: "Success",
 	_op: "Success",
 	[symbol$2](that) {
-		return isResult(that) && isSuccess$2(that) && equals$2(this.success, that.success);
+		return isResult$1(that) && isSuccess$2(that) && equals$2(this.success, that.success);
 	},
 	[symbol$3]() {
 		return combine$1(hash(this._tag))(hash(this.success));
@@ -4603,7 +4605,7 @@ const FailureProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(Com
 	_tag: "Failure",
 	_op: "Failure",
 	[symbol$2](that) {
-		return isResult(that) && isFailure$2(that) && equals$2(this.failure, that.failure);
+		return isResult$1(that) && isFailure$2(that) && equals$2(this.failure, that.failure);
 	},
 	[symbol$3]() {
 		return combine$1(hash(this._tag))(hash(this.failure));
@@ -4620,7 +4622,7 @@ const FailureProto = /*#__PURE__*/ Object.assign(/*#__PURE__*/ Object.create(Com
 	}
 });
 /** @internal */
-const isResult = (input) => hasProperty(input, TypeId$49);
+const isResult$1 = (input) => hasProperty(input, TypeId$51);
 /** @internal */
 const isFailure$2 = (result) => result._tag === "Failure";
 /** @internal */
@@ -5218,7 +5220,7 @@ const getOrElse$1 = /*#__PURE__*/ dual(2, (self, onNone) => isNone(self) ? onNon
 * @category error handling
 * @since 2.0.0
 */
-const orElse$1 = /*#__PURE__*/ dual(2, (self, that) => isNone(self) ? that() : self);
+const orElse$3 = /*#__PURE__*/ dual(2, (self, that) => isNone(self) ? that() : self);
 /**
 * Converts a nullable value (`null` or `undefined`) into an `Option`.
 *
@@ -5530,6 +5532,36 @@ const fail$7 = fail$8;
 */
 const failVoid = /*#__PURE__*/ fail$7(void 0);
 /**
+* Checks whether a value is a `Result` (either `Success` or `Failure`).
+*
+* **When to use**
+*
+* Use to validate unknown input before operating on it as a `Result`.
+*
+* **Details**
+*
+* - Returns `true` for both `Success` and `Failure` variants
+* - Acts as a TypeScript type guard, narrowing to `Result<unknown, unknown>`
+*
+* **Example** (Checking if a value is a Result)
+*
+* ```ts
+* import { Result } from "effect"
+*
+* console.log(Result.isResult(Result.succeed(1)))
+* // Output: true
+*
+* console.log(Result.isResult({ value: 1 }))
+* // Output: false
+* ```
+*
+* @see {@link isSuccess} / {@link isFailure} to narrow to a specific variant
+*
+* @category guards
+* @since 4.0.0
+*/
+const isResult = isResult$1;
+/**
 * Checks whether a `Result` is a `Failure`.
 *
 * **When to use**
@@ -6250,6 +6282,96 @@ function isOutOfBounds(i, as) {
 }
 const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
 /**
+* Reads an element at the given index safely, returning `Option.some` or
+* `Option.none` if the index is out of bounds.
+*
+* **When to use**
+*
+* Use when you need to read an array element by index and handle an
+* out-of-bounds index as `Option.none`.
+*
+* **Details**
+*
+* - The index is floored to an integer.
+* - Never throws.
+*
+* **Example** (Safe index access)
+*
+* ```ts
+* import { Array } from "effect"
+*
+* console.log(Array.get([1, 2, 3], 1)) // Some(2)
+* console.log(Array.get([1, 2, 3], 10)) // None
+* ```
+*
+* @see {@link getUnsafe} for indexed access that throws when the index is out of bounds
+* @see {@link head} for reading the first element as an `Option`
+* @see {@link last} for reading the last element as an `Option`
+*
+* @category getters
+* @since 2.0.0
+*/
+const get$10 = /*#__PURE__*/ dual(2, (self, index) => {
+	const i = Math.floor(index);
+	return isOutOfBounds(i, self) ? none() : some$1(self[i]);
+});
+/**
+* Reads an element at the given index, throwing if the index is out of bounds.
+*
+* **When to use**
+*
+* Use to read an element at a known valid index when out-of-bounds would be a
+* programming error.
+*
+* **Details**
+*
+* - Throws an `Error` with the message `"Index out of bounds: <i>"`.
+* - Prefer {@link get} for safe access.
+*
+* **Example** (Unsafe index access)
+*
+* ```ts
+* import { Array } from "effect"
+*
+* console.log(Array.getUnsafe([1, 2, 3], 1)) // 2
+* // Array.getUnsafe([1, 2, 3], 10) // throws Error
+* ```
+*
+* @see {@link get} — safe version returning `Option`
+*
+* @category unsafe
+* @since 4.0.0
+*/
+const getUnsafe$1 = /*#__PURE__*/ dual(2, (self, index) => {
+	const i = Math.floor(index);
+	if (isOutOfBounds(i, self)) throw new Error(`Index out of bounds: ${i}`);
+	return self[i];
+});
+/**
+* Returns the first element of an array safely wrapped in `Option.some`, or
+* `Option.none` if the array is empty.
+*
+* **When to use**
+*
+* Use to safely get the first element of an array that may be empty.
+*
+* **Example** (Getting the first element)
+*
+* ```ts
+* import { Array } from "effect"
+*
+* console.log(Array.head([1, 2, 3])) // Some(1)
+* console.log(Array.head([])) // None
+* ```
+*
+* @see {@link headNonEmpty} — direct access when array is known non-empty
+* @see {@link last} — get the last element
+*
+* @category getters
+* @since 2.0.0
+*/
+const head = /*#__PURE__*/ get$10(0);
+/**
 * Returns the first element of a `NonEmptyReadonlyArray` directly (no `Option`
 * wrapper).
 *
@@ -6271,11 +6393,7 @@ const clamp = (i, as) => Math.floor(Math.min(Math.max(0, i), as.length));
 * @category getters
 * @since 2.0.0
 */
-const headNonEmpty = /*#__PURE__*/ (/* @__PURE__ */ dual(2, (self, index) => {
-	const i = Math.floor(index);
-	if (isOutOfBounds(i, self)) throw new Error(`Index out of bounds: ${i}`);
-	return self[i];
-}))(0);
+const headNonEmpty = /*#__PURE__*/ getUnsafe$1(0);
 /**
 * Returns the last element of an array safely wrapped in `Option.some`, or
 * `Option.none` if the array is empty.
@@ -7059,7 +7177,7 @@ const ServiceProto = {
 	}
 };
 const ReferenceTypeId = "~effect/Context/Reference";
-const TypeId$48 = "~effect/Context";
+const TypeId$50 = "~effect/Context";
 /**
 * Creates a `Context` from an existing service map without validating or
 * copying it.
@@ -7094,7 +7212,7 @@ const makeUnsafe$8 = (mapUnsafe) => {
 };
 const Proto$15 = {
 	...PipeInspectableProto,
-	[TypeId$48]: { _Services: (_) => _ },
+	[TypeId$50]: { _Services: (_) => _ },
 	toJSON() {
 		return {
 			_id: "Context",
@@ -7146,7 +7264,7 @@ const Proto$15 = {
 * @category guards
 * @since 2.0.0
 */
-const isContext = (u) => hasProperty(u, TypeId$48);
+const isContext = (u) => hasProperty(u, TypeId$50);
 /**
 * Checks whether the provided argument is a `Reference`.
 *
@@ -7650,7 +7768,7 @@ const withMapUnsafe = (self, f) => {
 const Reference = Service;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Duration.js
-const TypeId$47 = "~effect/time/Duration";
+const TypeId$49 = "~effect/time/Duration";
 const bigint0$2 = /*#__PURE__*/ BigInt(0);
 const bigint1e3 = /*#__PURE__*/ BigInt(1e3);
 const bigint1e6 = /*#__PURE__*/ BigInt(1e6);
@@ -7709,7 +7827,7 @@ const fromInputUnsafe = (input) => {
 		}
 		case "object": {
 			if (input === null) break;
-			if (TypeId$47 in input) return input;
+			if (TypeId$49 in input) return input;
 			if (Array.isArray(input)) {
 				if (input.length !== 2 || !input.every(isNumber)) return invalid(input);
 				if (Number.isNaN(input[0]) || Number.isNaN(input[1])) return zero$1;
@@ -7744,7 +7862,7 @@ const zeroDurationValue = {
 const infinityDurationValue = { _tag: "Infinity" };
 const negativeInfinityDurationValue = { _tag: "NegativeInfinity" };
 const DurationProto = {
-	[TypeId$47]: TypeId$47,
+	[TypeId$49]: TypeId$49,
 	[symbol$3]() {
 		return structure(this.value);
 	},
@@ -7822,7 +7940,7 @@ const make$61 = (input) => {
 * @category guards
 * @since 2.0.0
 */
-const isDuration = (u) => hasProperty(u, TypeId$47);
+const isDuration = (u) => hasProperty(u, TypeId$49);
 /**
 * Checks whether a Duration is finite (not infinite).
 *
@@ -9669,7 +9787,7 @@ const provideServiceImpl = (self, service, implementation) => updateContext$1(se
 	return add(s, service, implementation);
 });
 /** @internal */
-const when$1 = /*#__PURE__*/ dual(2, (self, condition) => flatMap$4(condition, (pass) => pass ? asSome$1(self) : succeedNone$1));
+const when$3 = /*#__PURE__*/ dual(2, (self, condition) => flatMap$4(condition, (pass) => pass ? asSome$1(self) : succeedNone$1));
 /** @internal */
 const forever$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, options) => whileLoop$1({
 	while: constTrue,
@@ -9757,7 +9875,7 @@ const option$2 = (self) => match$1(self, {
 	onSuccess: some$1
 });
 /** @internal */
-const result = (self) => matchEager(self, {
+const result$1 = (self) => matchEager(self, {
 	onFailure: fail$7,
 	onSuccess: succeed$7
 });
@@ -10041,11 +10159,11 @@ const interruptibleMask$1 = (f) => withFiber$1((fiber) => {
 });
 /** @internal */
 const all$1 = (arg, options) => {
-	if (isIterable(arg)) return options?.mode === "result" ? forEach$2(arg, result, options) : forEach$2(arg, identity, options);
-	else if (options?.discard) return options.mode === "result" ? forEach$2(Object.values(arg), result, options) : forEach$2(Object.values(arg), identity, options);
+	if (isIterable(arg)) return options?.mode === "result" ? forEach$2(arg, result$1, options) : forEach$2(arg, identity, options);
+	else if (options?.discard) return options.mode === "result" ? forEach$2(Object.values(arg), result$1, options) : forEach$2(Object.values(arg), identity, options);
 	return suspend$3(() => {
 		const out = {};
-		return as$1(forEach$2(Object.entries(arg), ([key, effect]) => map$6(options?.mode === "result" ? result(effect) : effect, (value) => {
+		return as$1(forEach$2(Object.entries(arg), ([key, effect]) => map$6(options?.mode === "result" ? result$1(effect) : effect, (value) => {
 			out[key] = value;
 		}), {
 			discard: true,
@@ -10699,7 +10817,7 @@ const reportCauseUnsafe = (fiber, cause, defectsOnly) => {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Deferred.js
-const TypeId$46 = "~effect/Deferred";
+const TypeId$48 = "~effect/Deferred";
 /**
 * Checks whether a value is a `Deferred`.
 *
@@ -10711,9 +10829,9 @@ const TypeId$46 = "~effect/Deferred";
 * @category guards
 * @since 4.0.0
 */
-const isDeferred = (u) => hasProperty(u, TypeId$46);
+const isDeferred = (u) => hasProperty(u, TypeId$48);
 const DeferredProto = {
-	[TypeId$46]: {
+	[TypeId$48]: {
 		_A: identity,
 		_E: identity
 	},
@@ -11755,14 +11873,14 @@ const close = scopeClose;
 const closeUnsafe = scopeCloseUnsafe;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Layer.js
-const TypeId$45 = "~effect/Layer";
+const TypeId$47 = "~effect/Layer";
 const MemoMapTypeId = "~effect/Layer/MemoMap";
 const memoMapReuse = (entry, scope) => {
 	entry.observers++;
 	return andThen$1(scopeAddFinalizerExit(scope, (exit) => entry.finalizer(exit)), entry.effect);
 };
 const LayerProto = {
-	[TypeId$45]: {
+	[TypeId$47]: {
 		_ROut: identity,
 		_E: identity,
 		_RIn: identity
@@ -13557,11 +13675,11 @@ const Clock = ClockRef;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/internal/dateTime.js
 /** @internal */
-const TypeId$44 = "~effect/time/DateTime";
+const TypeId$46 = "~effect/time/DateTime";
 /** @internal */
 const TimeZoneTypeId = "~effect/time/DateTime/TimeZone";
 const Proto$14 = {
-	[TypeId$44]: TypeId$44,
+	[TypeId$46]: TypeId$46,
 	pipe() {
 		return pipeArguments(this, arguments);
 	},
@@ -14005,6 +14123,243 @@ const matchEffect$1 = /*#__PURE__*/ dual(2, (self, options) => matchCauseEffect$
 		return !isFailure$1(halt) ? options.onDone(halt.success.value) : options.onFailure(halt.failure);
 	}
 }));
+const ScheduleProto = {
+	["~effect/Schedule"]: {
+		_Out: identity,
+		_In: identity,
+		_Env: identity
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+/**
+* Creates a Schedule from a step function that returns a Pull.
+*
+* **Example** (Creating a custom schedule from a step function)
+*
+* ```ts
+* import { Cause, Duration, Effect, Schedule } from "effect"
+*
+* const schedule = Schedule.fromStep(Effect.sync(() => {
+*   let count = 0
+*
+*   return (_now: number, _input: string) => {
+*     if (count >= 3) {
+*       return Cause.done(count)
+*     }
+*     return Effect.succeed([count++, Duration.millis(100)] as [number, Duration.Duration])
+*   }
+* }))
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fromStep = (step) => {
+	const self = Object.create(ScheduleProto);
+	self.step = step;
+	return self;
+};
+const metadataFn = () => {
+	let n = 0;
+	let previous;
+	let start;
+	return (now, input) => {
+		if (start === void 0) start = now;
+		const elapsed = now - start;
+		const elapsedSincePrevious = previous === void 0 ? 0 : now - previous;
+		previous = now;
+		return {
+			input,
+			attempt: ++n,
+			start,
+			now,
+			elapsed,
+			elapsedSincePrevious
+		};
+	};
+};
+/**
+* Creates a Schedule from a step function that receives metadata about the schedule's execution.
+*
+* **Example** (Creating a metadata-aware schedule)
+*
+* ```ts
+* import { Cause, Duration, Effect, Schedule } from "effect"
+*
+* const firstThreeInputs = Schedule.fromStepWithMetadata(Effect.succeed((metadata: Schedule.InputMetadata<string>) => {
+*   if (metadata.attempt > 3) {
+*     return Cause.done("finished")
+*   }
+*
+*   return Effect.succeed([
+*     `attempt ${metadata.attempt}: ${metadata.input}`,
+*     Duration.millis(250)
+*   ] as [string, Duration.Duration])
+* }))
+* ```
+*
+* @category constructors
+* @since 4.0.0
+*/
+const fromStepWithMetadata = (step) => fromStep(map$6(step, (f) => {
+	const meta = metadataFn();
+	return (now, input) => f(meta(now, input));
+}));
+/**
+* Extracts the step function from a Schedule.
+*
+* **Example** (Extracting a schedule step function)
+*
+* ```ts
+* import { Effect, Schedule } from "effect"
+*
+* // Extract step function from an existing schedule
+* const schedule = Schedule.exponential("100 millis").pipe(Schedule.take(3))
+*
+* const program = Effect.gen(function*() {
+*   const stepFn = yield* Schedule.toStep(schedule)
+*
+*   // Use the step function directly for custom logic. The timestamp is
+*   // supplied by the caller, so tests can pass a deterministic value.
+*   const now = 0
+*   const result = yield* stepFn(now, "input")
+*
+*   console.log(`Step result: ${result}`)
+* })
+* ```
+*
+* @category destructors
+* @since 4.0.0
+*/
+const toStep = (schedule) => catchCause$2(schedule.step, (cause) => succeed$6(() => failCause$5(cause)));
+/**
+* Extracts a step function from a `Schedule` that sleeps for each computed
+* delay and returns metadata for the completed step.
+*
+* **When to use**
+*
+* Use to drive a schedule manually while preserving the computed output,
+* delay, input, attempt, and elapsed timing metadata for each step.
+*
+* **Details**
+*
+* The returned step reads the current time from `Clock` when invoked, calls the
+* schedule step with that timestamp and input, sleeps for the returned
+* duration, and then yields `Metadata`.
+*
+* @see {@link toStep} for manually supplying the timestamp and handling the returned delay yourself
+* @see {@link toStepWithSleep} for the same automatic sleeping behavior when only the schedule output is needed
+*
+* @category destructors
+* @since 4.0.0
+*/
+const toStepWithMetadata = (schedule) => clockWith$1((clock) => map$6(toStep(schedule), (step) => {
+	const metaFn = metadataFn();
+	return (input) => suspend$3(() => {
+		const now = clock.currentTimeMillisUnsafe();
+		return flatMap$4(step(now, input), ([output, duration]) => {
+			const meta = metaFn(now, input);
+			meta.output = output;
+			meta.duration = duration;
+			return as$1(sleep$1(duration), meta);
+		});
+	});
+}));
+/**
+* Extracts a step function from a Schedule that automatically handles sleep delays.
+*
+* **Example** (Extracting a sleeping step function)
+*
+* ```ts
+* import { Effect, Schedule } from "effect"
+*
+* // Convert schedule to step function with automatic sleeping
+* const schedule = Schedule.spaced("1 second").pipe(Schedule.take(3))
+*
+* const program = Effect.gen(function*() {
+*   const stepWithSleep = yield* Schedule.toStepWithSleep(schedule)
+*
+*   // Each call will automatically sleep for the scheduled delay
+*   console.log("Starting...")
+*   const result1 = yield* stepWithSleep("first")
+*   console.log(`First result: ${result1}`)
+*
+*   const result2 = yield* stepWithSleep("second")
+*   console.log(`Second result: ${result2}`)
+*
+*   const result3 = yield* stepWithSleep("third")
+*   console.log(`Third result: ${result3}`)
+* })
+* ```
+*
+* @category destructors
+* @since 4.0.0
+*/
+const toStepWithSleep = (schedule) => map$6(toStepWithMetadata(schedule), (step) => (input) => map$6(step(input), (meta) => meta.output));
+/**
+* Returns a schedule that recurs continuously, each repetition spaced the
+* specified duration from the last run.
+*
+* **When to use**
+*
+* Use when each delay should start after the previous action
+* completes. Use `fixed` when recurrences should stay aligned to a regular
+* cadence.
+*
+* **Example** (Repeating with fixed spacing)
+*
+* ```ts
+* import { Console, Effect, Schedule } from "effect"
+*
+* // Basic spaced schedule - runs every 2 seconds
+* const everyTwoSeconds = Schedule.spaced("2 seconds")
+*
+* // Heartbeat that runs indefinitely with fixed spacing
+* const heartbeat = Effect.gen(function*() {
+*   yield* Console.log("Heartbeat")
+* }).pipe(
+*   Effect.repeat(everyTwoSeconds)
+* )
+*
+* // Limited repeat - run only 5 times with 1-second spacing
+* const limitedTask = Effect.gen(function*() {
+*   yield* Console.log("Executing scheduled task...")
+*   yield* Effect.sleep("500 millis") // simulate work
+*   return "Task completed"
+* }).pipe(
+*   Effect.repeat(
+*     Schedule.spaced("1 second").pipe(Schedule.take(5))
+*   )
+* )
+*
+* // Simple spaced schedule with limited repetitions
+* const limitedSpaced = Schedule.spaced("100 millis").pipe(
+*   Schedule.both(Schedule.recurs(5)) // at most 5 times
+* )
+*
+* const program = Effect.gen(function*() {
+*   yield* Console.log("Starting spaced execution...")
+*
+*   yield* Effect.repeat(
+*     Effect.succeed("work item"),
+*     limitedSpaced
+*   )
+*
+*   yield* Console.log("Completed executions")
+* })
+* ```
+*
+* @see {@link fixed} for recurrence aligned to a regular cadence
+*
+* @category constructors
+* @since 2.0.0
+*/
+const spaced = (duration) => {
+	const decoded = fromInputUnsafe(duration);
+	return fromStepWithMetadata(succeed$6((meta) => succeed$6([meta.attempt - 1, decoded])));
+};
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/internal/layer.js
 const provideLayer = (self, layer, options) => scopedWith$1((scope) => flatMap$4(options?.local ? buildWithMemoMap(layer, makeMemoMapUnsafe(), scope) : buildWithScope(layer, scope), (context) => provideContext$3(self, context)));
@@ -16012,7 +16367,7 @@ const raceFirst = raceFirst$1;
 * @category conditional operators
 * @since 2.0.0
 */
-const when = when$1;
+const when$2 = when$3;
 /**
 * Handles success or failure eagerly with effectful handlers when the effect is already resolved.
 *
@@ -18202,7 +18557,7 @@ const redactedRegistry = /*#__PURE__*/ new WeakMap();
 *
 * @since 3.3.0
 */
-const TypeId$43 = "~effect/data/Redacted";
+const TypeId$44 = "~effect/data/Redacted";
 /**
 * Returns `true` if a value is a `Redacted` wrapper.
 *
@@ -18230,7 +18585,7 @@ const TypeId$43 = "~effect/data/Redacted";
 * @category refinements
 * @since 3.3.0
 */
-const isRedacted = (u) => hasProperty(u, TypeId$43);
+const isRedacted = (u) => hasProperty(u, TypeId$44);
 /**
 * Creates a `Redacted` wrapper for a sensitive value.
 *
@@ -18263,7 +18618,7 @@ const make$56 = (value, options) => {
 	return self;
 };
 const Proto$13 = {
-	[TypeId$43]: { _A: (_) => _ },
+	[TypeId$44]: { _A: (_) => _ },
 	label: void 0,
 	...PipeInspectableProto,
 	toJSON() {
@@ -18281,7 +18636,7 @@ const Proto$13 = {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/SchemaIssue.js
-const TypeId$42 = "~effect/SchemaIssue/Issue";
+const TypeId$43 = "~effect/SchemaIssue/Issue";
 /**
 * Returns `true` if the given value is an {@link Issue}.
 *
@@ -18312,10 +18667,10 @@ const TypeId$42 = "~effect/SchemaIssue/Issue";
 * @since 4.0.0
 */
 function isIssue(u) {
-	return hasProperty(u, TypeId$42);
+	return hasProperty(u, TypeId$43);
 }
 var Base$1 = class {
-	[TypeId$42] = TypeId$42;
+	[TypeId$43] = TypeId$43;
 	toString() {
 		return defaultFormatter(this);
 	}
@@ -19443,9 +19798,9 @@ function split(options) {
 *
 * @since 2.0.0
 */
-const TypeId$41 = "~effect/BigDecimal";
+const TypeId$42 = "~effect/BigDecimal";
 const BigDecimalProto = {
-	[TypeId$41]: TypeId$41,
+	[TypeId$42]: TypeId$42,
 	[symbol$3]() {
 		const normalized = normalize(this);
 		return combine$1(hash(normalized.value), number$1(normalized.scale));
@@ -19491,7 +19846,7 @@ const BigDecimalProto = {
 * @category guards
 * @since 2.0.0
 */
-const isBigDecimal = (u) => hasProperty(u, TypeId$41);
+const isBigDecimal = (u) => hasProperty(u, TypeId$42);
 /**
 * Creates a `BigDecimal` from a `bigint` value and a scale.
 *
@@ -19826,7 +20181,7 @@ const isZero = (n) => n.value === bigint0;
 const isNegative = (n) => n.value < bigint0;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/SchemaTransformation.js
-const TypeId$40 = "~effect/SchemaTransformation/Transformation";
+const TypeId$41 = "~effect/SchemaTransformation/Transformation";
 /**
 * Represents a bidirectional transformation between a decoded type `T` and an encoded
 * type `E`, built from a pair of `Getter`s.
@@ -19869,7 +20224,7 @@ const TypeId$40 = "~effect/SchemaTransformation/Transformation";
 * @since 4.0.0
 */
 var Transformation = class Transformation {
-	[TypeId$40] = TypeId$40;
+	[TypeId$41] = TypeId$41;
 	_tag = "Transformation";
 	decode;
 	encode;
@@ -19915,7 +20270,7 @@ var Transformation = class Transformation {
 * @since 4.0.0
 */
 function isTransformation(u) {
-	return hasProperty(u, TypeId$40);
+	return hasProperty(u, TypeId$41);
 }
 /**
 * Constructs a `Transformation` from an object with `decode` and `encode`
@@ -20297,7 +20652,7 @@ var Context = class {
 		this.annotations = annotations;
 	}
 };
-const TypeId$39 = "~effect/Schema";
+const TypeId$40 = "~effect/Schema";
 /**
 * Represents the abstract base class for all {@link AST} node variants.
 *
@@ -20319,7 +20674,7 @@ const TypeId$39 = "~effect/Schema";
 * @since 4.0.0
 */
 var Base = class {
-	[TypeId$39] = TypeId$39;
+	[TypeId$40] = TypeId$40;
 	annotations;
 	checks;
 	encoding;
@@ -22082,7 +22437,7 @@ function nominal() {
 *
 * @since 4.0.0
 */
-const TypeId$38 = "~effect/platform/PlatformError";
+const TypeId$39 = "~effect/platform/PlatformError";
 /**
 * Error data for an invalid argument passed to a platform API.
 *
@@ -22192,7 +22547,7 @@ var PlatformError = class extends TaggedError("PlatformError") {
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$38] = TypeId$38;
+	[TypeId$39] = TypeId$39;
 	get message() {
 		return this.reason.message;
 	}
@@ -22854,7 +23209,7 @@ const takeAll$2 = (self) => takeN(self, self.length);
 * @category elements
 * @since 4.0.0
 */
-const take$3 = (self) => {
+const take$4 = (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;
@@ -22977,9 +23332,9 @@ const filter$1 = (self, f) => {
 const remove$5 = (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$37 = "~effect/MutableRef";
+const TypeId$38 = "~effect/MutableRef";
 const MutableRefProto = {
-	[TypeId$37]: TypeId$37,
+	[TypeId$38]: TypeId$38,
 	...PipeInspectableProto,
 	toJSON() {
 		return {
@@ -23165,7 +23520,7 @@ const set$6 = /*#__PURE__*/ dual(2, (self, value) => {
 *
 * @since 2.0.0
 */
-const TypeId$36 = "~effect/PubSub";
+const TypeId$37 = "~effect/PubSub";
 const SubscriptionTypeId = "~effect/PubSub/Subscription";
 /**
 * Creates a PubSub with a custom atomic implementation and strategy.
@@ -23356,7 +23711,7 @@ const makeAtomicUnbounded = (options) => new UnboundedPubSub(options?.replay ? n
 */
 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(self.shutdownHook.open), asVoid);
+	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
@@ -23521,7 +23876,7 @@ const unsubscribe = (self) => uninterruptible(withFiber((state) => {
 		self.subscribers.delete(self.subscription);
 		self.subscription.unsubscribe();
 		self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
-	})), when(self.shutdownHook.open), asVoid);
+	})), when$2(self.shutdownHook.open), asVoid);
 }));
 /**
 * Takes a single message from the subscription. If no messages are available,
@@ -23556,7 +23911,7 @@ const unsubscribe = (self) => uninterruptible(withFiber((state) => {
 * @category subscriptions
 * @since 4.0.0
 */
-const take$2 = (self) => suspend$2(() => {
+const take$3 = (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;
@@ -24231,7 +24586,7 @@ var SubscriptionImpl = class {
 	}
 };
 var PubSubImpl = class {
-	[TypeId$36] = { _A: identity };
+	[TypeId$37] = { _A: identity };
 	pubsub;
 	subscribers;
 	scope;
@@ -24302,7 +24657,7 @@ var BackPressureStrategy = class {
 	onPubSubEmptySpaceUnsafe(pubsub, subscribers) {
 		let keepPolling = true;
 		while (keepPolling && !pubsub.isFull()) {
-			const publisher = take$3(this.publishers);
+			const publisher = take$4(this.publishers);
 			if (publisher === Empty$2) keepPolling = false;
 			else {
 				const [value, deferred] = publisher;
@@ -24414,7 +24769,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$4(pollers);
 		if (poller === Empty$2) {
 			removeSubscribers(subscribers, subscription, pollers);
 			if (pollers.length === 0) keepPolling = false;
@@ -24578,7 +24933,7 @@ const emptyReplayWindow = {
 *
 * @since 3.8.0
 */
-const TypeId$35 = "~effect/Queue";
+const TypeId$36 = "~effect/Queue";
 const EnqueueTypeId = "~effect/Queue/Enqueue";
 const DequeueTypeId = "~effect/Queue/Dequeue";
 const variance$1 = {
@@ -24586,7 +24941,7 @@ const variance$1 = {
 	_E: identity
 };
 const QueueProto = {
-	[TypeId$35]: variance$1,
+	[TypeId$36]: variance$1,
 	[EnqueueTypeId]: variance$1,
 	[DequeueTypeId]: variance$1,
 	...PipeInspectableProto,
@@ -24685,6 +25040,43 @@ const make$48 = (options) => withFiber$1((fiber) => {
 */
 const bounded = (capacity) => make$48({ capacity });
 /**
+* Creates a bounded queue with sliding strategy. When the queue reaches capacity,
+* new elements are added and the oldest elements are dropped.
+*
+* **When to use**
+*
+* Use when producers should not block and message loss is acceptable.
+* Useful when you want to maintain a rolling window of the most recent messages.
+*
+* **Example** (Creating sliding queues)
+*
+* ```ts
+* import { Effect, Queue } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const queue = yield* Queue.sliding<number>(3)
+*
+*   // Fill the queue to capacity
+*   yield* Queue.offer(queue, 1)
+*   yield* Queue.offer(queue, 2)
+*   yield* Queue.offer(queue, 3)
+*
+*   // This will succeed, dropping the oldest element (1)
+*   yield* Queue.offer(queue, 4)
+*
+*   const all = yield* Queue.takeAll(queue)
+*   console.log(all) // [2, 3, 4] - oldest element (1) was dropped
+* })
+* ```
+*
+* @category constructors
+* @since 2.0.0
+*/
+const sliding = (capacity) => make$48({
+	capacity,
+	strategy: "sliding"
+});
+/**
 * Creates an unbounded queue that can grow to any size without blocking producers.
 *
 * **When to use**
@@ -24763,7 +25155,7 @@ const offer = (self, message) => suspend$3(() => {
 			}
 			return offerRemainingSingle(self, message);
 		case "sliding":
-			take$3(self.messages);
+			take$4(self.messages);
 			append(self.messages, message);
 			return exitTrue;
 	}
@@ -24806,7 +25198,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$4(self.messages);
 			append(self.messages, message);
 			return true;
 		} else if (self.capacity <= 0 && self.state.takers.size > 0) {
@@ -25169,7 +25561,7 @@ const takeBetween = (self, min, max) => suspend$3(() => takeBetweenUnsafe(self,
 * @category taking
 * @since 2.0.0
 */
-const take$1 = (self) => suspend$3(() => takeUnsafe(self) ?? andThen$1(awaitTake(self), take$1(self)));
+const take$2 = (self) => suspend$3(() => takeUnsafe(self) ?? andThen$1(awaitTake(self), take$2(self)));
 /**
 * Attempts to take one message from the queue synchronously.
 *
@@ -25211,14 +25603,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$4(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$4(self.messages);
 		releaseCapacity(self);
 		return exitSucceed(message);
 	}
@@ -25290,7 +25682,7 @@ const takeBetweenUnsafe = (self, min, max) => {
 		self.capacity = 1;
 		releaseCapacity(self);
 		self.capacity = 0;
-		const messages = [take$3(self.messages)];
+		const messages = [take$4(self.messages)];
 		releaseCapacity(self);
 		return exitSucceed(messages);
 	}
@@ -25612,7 +26004,7 @@ const withPermit = (self, effect) => {
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$34 = "~effect/Channel";
+const TypeId$35 = "~effect/Channel";
 /**
 * Checks whether a value is a `Channel`.
 *
@@ -25629,9 +26021,9 @@ const TypeId$34 = "~effect/Channel";
 * @category guards
 * @since 3.5.4
 */
-const isChannel = (u) => hasProperty(u, TypeId$34);
+const isChannel = (u) => hasProperty(u, TypeId$35);
 const ChannelProto = {
-	[TypeId$34]: {
+	[TypeId$35]: {
 		_Env: identity,
 		_InErr: identity,
 		_InElem: identity,
@@ -26449,7 +26841,7 @@ const mapEffectConcurrent = (self, f, options) => fromTransformBracket(fnUntrace
 	} else {
 		const effects = yield* bounded(concurrencyN - 2);
 		yield* addFinalizer$1(forkedScope, shutdown(queue));
-		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));
+		yield* take$2(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;
@@ -26464,7 +26856,7 @@ const mapEffectConcurrent = (self, f, options) => fromTransformBracket(fnUntrace
 			return offer(effects, join$1(fiber));
 		}), forever({ disableYield: true }), catchCause$1((cause) => offer(effects, failCause$3(cause)).pipe(andThen(failCause$1(effects, cause)))), forkIn(forkedScope));
 	}
-	return take$1(queue);
+	return take$2(queue);
 }));
 /**
 * Maps each output element to a channel and flattens the child channel
@@ -26615,26 +27007,6 @@ const filterArray = /*#__PURE__*/ dual(2, (self, predicate) => transformPull$1(s
 	return isReadonlyArrayNonEmpty(passes) ? succeed$3(passes) : flatMap$2(pull, loop);
 }))));
 /**
-* Filters and maps each element inside emitted non-empty arrays using a
-* `Filter`.
-*
-* **Details**
-*
-* Successful filter results are kept as mapped values. Failed filter results
-* are removed from the array. Arrays that become empty are discarded.
-*
-* @category filtering
-* @since 4.0.0
-*/
-const filterMapArray = /*#__PURE__*/ dual(2, (self, filter) => transformPull$1(self, (pull) => succeed$3(flatMap$2(pull, function loop(arr) {
-	const passes = [];
-	for (let i = 0; i < arr.length; i++) {
-		const result = filter(arr[i]);
-		if (isSuccess$1(result)) passes.push(result.success);
-	}
-	return isReadonlyArrayNonEmpty(passes) ? succeed$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.
 *
@@ -26803,7 +27175,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$1(queue);
+	return take$2(queue);
 })));
 /**
 * Returns a new channel, which is the merge of this channel and the specified
@@ -26852,7 +27224,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$1(queue);
+	return take$2(queue);
 })));
 /**
 * Splits upstream string chunks into lines, recognizing `\n`, `\r\n`, and
@@ -27211,14 +27583,14 @@ const runFold = /*#__PURE__*/ dual(3, (self, initial, f) => suspend$2(() => {
 const toPullScoped = (self, scope) => toTransform(self)(done(), scope);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/internal/stream.js
-const TypeId$33 = "~effect/Stream";
+const TypeId$34 = "~effect/Stream";
 const streamVariance = {
 	_R: identity,
 	_E: identity,
 	_A: identity
 };
 const StreamProto = {
-	[TypeId$33]: streamVariance,
+	[TypeId$34]: streamVariance,
 	pipe() {
 		return pipeArguments(this, arguments);
 	}
@@ -27231,7 +27603,7 @@ const fromChannel$2 = (channel) => {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Sink.js
-const TypeId$32 = "~effect/Sink";
+const TypeId$33 = "~effect/Sink";
 const endVoid = /*#__PURE__*/ succeed$3([void 0]);
 const sinkVariance = {
 	_A: identity,
@@ -27241,7 +27613,7 @@ const sinkVariance = {
 	_R: identity
 };
 const SinkProto = {
-	[TypeId$32]: sinkVariance,
+	[TypeId$33]: sinkVariance,
 	pipe() {
 		return pipeArguments(this, arguments);
 	}
@@ -27264,7 +27636,7 @@ const SinkProto = {
 * @category guards
 * @since 4.0.0
 */
-const isSink = (u) => hasProperty(u, TypeId$32);
+const isSink = (u) => hasProperty(u, TypeId$33);
 /**
 * Creates a sink from a `Channel`.
 *
@@ -27328,6 +27700,38 @@ const toChannel$1 = (self) => fromTransform$1((upstream, scope) => succeed$3(fla
 */
 const drain = /*#__PURE__*/ fromTransform((upstream) => catchDone(forever(upstream, { disableYield: true }), () => endVoid));
 /**
+* Collects up to `n` input elements into an array.
+*
+* **Details**
+*
+* If `n` is less than or equal to zero, the sink completes with an empty array.
+* If more elements are pulled than needed, the remaining elements from the same
+* array are returned as leftovers.
+*
+* @category collecting
+* @since 2.0.0
+*/
+const take$1 = (n) => fromTransform((upstream) => {
+	const taken = [];
+	if (n <= 0) return succeed$3([taken]);
+	let leftover = void 0;
+	return upstream.pipe(flatMap$2((arr) => {
+		if (taken.length + arr.length <= n) {
+			taken.push(...arr);
+			if (taken.length === n) return done();
+			return void_$1;
+		}
+		for (let i = 0; i < arr.length; i++) {
+			taken.push(arr[i]);
+			if (taken.length === n) {
+				if (i + 1 < arr.length) leftover = arr.slice(i + 1);
+				return done();
+			}
+		}
+		return void_$1;
+	}), forever({ disableYield: true }), catchDone(() => succeed$3([taken, leftover])));
+});
+/**
 * A sink that executes the provided effectful function for every item fed
 * to it.
 *
@@ -27413,9 +27817,9 @@ const forEachArray = (f) => fromTransform((upstream) => upstream.pipe(flatMap$2(
 const unwrap$2 = (effect) => fromChannel$1(unwrap$3(map$4(effect, toChannel$1)));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/MutableHashMap.js
-const TypeId$31 = "~effect/collections/MutableHashMap";
+const TypeId$32 = "~effect/collections/MutableHashMap";
 const MutableHashMapProto = {
-	[TypeId$31]: TypeId$31,
+	[TypeId$32]: TypeId$32,
 	[Symbol.iterator]() {
 		return this.backing[Symbol.iterator]();
 	},
@@ -27783,9 +28187,9 @@ const size = (self) => self.backing.size;
 *
 * @since 3.5.0
 */
-const TypeId$30 = "~effect/RcMap";
+const TypeId$31 = "~effect/RcMap";
 const makeUnsafe$2 = (options) => ({
-	[TypeId$30]: TypeId$30,
+	[TypeId$31]: TypeId$31,
 	lookup: options.lookup,
 	context: options.context,
 	scope: options.scope,
@@ -27962,7 +28366,7 @@ const release = (self, key, entry) => withFiber((fiber) => {
 });
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/internal/rcRef.js
-const TypeId$29 = "~effect/RcRef";
+const TypeId$30 = "~effect/RcRef";
 const stateEmpty = { _tag: "Empty" };
 const stateClosed = { _tag: "Closed" };
 const variance = {
@@ -27970,7 +28374,7 @@ const variance = {
 	_E: identity
 };
 var RcRefImpl = class {
-	[TypeId$29] = variance;
+	[TypeId$30] = variance;
 	pipe() {
 		return pipeArguments(this, arguments);
 	}
@@ -28235,7 +28639,7 @@ const get$4 = get$5;
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$28 = "~effect/Stream";
+const TypeId$29 = "~effect/Stream";
 /**
 * Checks whether a value is a Stream.
 *
@@ -28260,7 +28664,7 @@ const TypeId$28 = "~effect/Stream";
 * @category guards
 * @since 4.0.0
 */
-const isStream = (u) => hasProperty(u, TypeId$28);
+const isStream = (u) => hasProperty(u, TypeId$29);
 /**
 * Creates a stream from a array-emitting `Channel`.
 *
@@ -28933,26 +29337,6 @@ const merge$1 = /*#__PURE__*/ dual((args) => isStream(args[0]) && isStream(args[
 * @since 2.0.0
 */
 const filter = /*#__PURE__*/ dual(2, (self, predicate) => fromChannel(filterArray(toChannel(self), predicate)));
-/**
-* Filters and maps stream elements in one pass using a `Filter`.
-*
-* **When to use**
-*
-* Use to keep only stream elements accepted by a `Filter` and emit each filter
-* success value.
-*
-* **Details**
-*
-* `Result.succeed` values are emitted and `Result.fail` values are skipped.
-*
-* @see {@link filter} for keeping original elements with a boolean predicate or refinement
-* @see {@link filterMapEffect} for an effectful `Filter`
-* @see {@link partition} for consuming both filter success and failure values
-*
-* @category filtering
-* @since 2.0.0
-*/
-const filterMap = /*#__PURE__*/ dual(2, (self, filter) => fromChannel(filterMapArray(toChannel(self), filter)));
 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.
@@ -29156,6 +29540,31 @@ const debounce = /*#__PURE__*/ dual(2, (self, duration) => transformPull(self, f
 	});
 })));
 /**
+* Partitions the stream into arrays, emitting when the chunk size is reached
+* or the duration passes.
+*
+* **Example** (Grouping elements by size or time)
+*
+* ```ts
+* import { Console, Effect, Stream } from "effect"
+*
+* const program = Effect.gen(function*() {
+*   const values = yield* Stream.make(1, 2, 3).pipe(
+*     Stream.groupedWithin(2, "5 seconds"),
+*     Stream.runCollect
+*   )
+*   yield* Console.log(values)
+* })
+*
+* Effect.runPromise(program)
+* // Output: [ [ 1, 2 ], [ 3 ] ]
+* ```
+*
+* @category grouping
+* @since 2.0.0
+*/
+const groupedWithin = /*#__PURE__*/ dual(3, (self, chunkSize, duration) => aggregateWithin(self, take$1(chunkSize), spaced(duration)));
+/**
 * Applies a sink transducer to the stream and emits each sink result.
 *
 * **Example** (Transducing with a sink)
@@ -29198,6 +29607,78 @@ const transduce = /*#__PURE__*/ dual(2, (self, sink) => transformPull(self, (ups
 	return suspend$2(() => done$5 ? done$5 : pull);
 })));
 /**
+* Aggregates elements with a sink, emitting each result when the sink completes or the schedule triggers.
+*
+* **Details**
+*
+* The schedule can flush the current aggregation even if the sink has not finished.
+*
+* **Example** (Aggregating with a sink and schedule)
+*
+* ```ts
+* import { Console, Effect, Schedule, Sink, Stream } from "effect"
+*
+* Effect.runPromise(Effect.gen(function* () {
+*   const aggregated = yield* Stream.runCollect(
+*     Stream.make(1, 2, 3, 4, 5, 6).pipe(
+*       Stream.aggregateWithin(
+*         Sink.foldUntil(() => 0, 3, (sum, n) => Effect.succeed(sum + n)),
+*         Schedule.spaced("1 minute")
+*       )
+*     )
+*   )
+*   yield* Console.log(aggregated)
+* }))
+* // Output: [ 6, 15 ]
+* ```
+*
+* @category Aggregation
+* @since 2.0.0
+*/
+const aggregateWithin = /*#__PURE__*/ dual(3, (self, sink, schedule) => fromChannel(fromTransformBracket(fnUntraced(function* (_upstream, _, scope) {
+	const pull = yield* toPullScoped(self.channel, _);
+	const pullLatch = makeUnsafe$4(false);
+	const scheduleStep = Symbol();
+	const buffer = yield* make$48({ capacity: 0 });
+	yield* pull.pipe(pullLatch.whenOpen, flatMap$2((arr) => {
+		pullLatch.closeUnsafe();
+		return offer(buffer, arr);
+	}), forever, catchCause$1((cause) => failCause$1(buffer, cause)), forkIn(scope));
+	let lastOutput = none();
+	let leftover;
+	let sinkHasInput = false;
+	const step = yield* toStepWithSleep(schedule);
+	const stepToBuffer = suspend$2(function loop() {
+		return step(lastOutput).pipe(flatMap$2(() => !sinkHasInput ? loop() : offer(buffer, scheduleStep)), flatMap$2(() => never$1), catchDone(() => done()));
+	});
+	const pullFromBuffer = take$2(buffer).pipe(flatMap$2((arr) => {
+		if (arr === scheduleStep) return done();
+		sinkHasInput = true;
+		return succeed$3(arr);
+	}));
+	const sinkUpstream = suspend$2(() => {
+		if (leftover !== void 0) {
+			const chunk = leftover;
+			leftover = void 0;
+			sinkHasInput = true;
+			return succeed$3(chunk);
+		}
+		pullLatch.openUnsafe();
+		return pullFromBuffer;
+	});
+	const catchSinkHalt = flatMap$2(([value, leftover_]) => {
+		if (!sinkHasInput && buffer.state._tag === "Done") return done();
+		lastOutput = some$1(value);
+		leftover = leftover_;
+		return succeed$3(of(value));
+	});
+	return suspend$2(() => {
+		if (buffer.state._tag === "Done" && leftover === void 0) return buffer.state.exit;
+		sinkHasInput = leftover !== void 0;
+		return succeed$3(suspend$2(() => sink.transform(sinkUpstream, scope)));
+	}).pipe(flatMap$2((pull) => raceFirst(catchSinkHalt(pull), stepToBuffer)));
+}))));
+/**
 * Returns a stream that only emits elements that are not equal to the previously emitted element, as determined by the specified predicate.
 *
 * **Example** (Emitting values that changed by equivalence)
@@ -29636,7 +30117,7 @@ const toReadableStreamEffect = /*#__PURE__*/ dual((args) => isStream(args[0]), (
 *
 * @since 4.0.0
 */
-const TypeId$27 = "~effect/platform/FileSystem";
+const TypeId$28 = "~effect/platform/FileSystem";
 /**
 * Creates a `Size` from various numeric input types.
 *
@@ -29746,7 +30227,7 @@ const FileSystem = /*#__PURE__*/ Service("effect/platform/FileSystem");
 */
 const make$42 = (impl) => FileSystem.of({
 	...impl,
-	[TypeId$27]: TypeId$27,
+	[TypeId$28]: TypeId$28,
 	exists: (path) => pipe(impl.access(path), as(true), catchTag("PlatformError", (e) => e.reason._tag === "NotFound" ? succeed$3(false) : fail$3(e))),
 	readFileString: (path, encoding) => flatMap$2(impl.readFile(path), (_) => try_({
 		try: () => new TextDecoder(encoding).decode(_),
@@ -29920,7 +30401,7 @@ var WatchBackend = class extends Service()("effect/platform/FileSystem/WatchBack
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$26 = "~effect/platform/Path";
+const TypeId$27 = "~effect/platform/Path";
 /**
 * Service tag for accessing the current `Path` implementation.
 *
@@ -30113,7 +30594,7 @@ var ChildProcessSpawner = class extends Service()("effect/process/ChildProcessSp
 *
 * @since 4.0.0
 */
-const TypeId$25 = "~effect/unstable/process/ChildProcess";
+const TypeId$26 = "~effect/unstable/process/ChildProcess";
 const Proto$12 = {
 	.../*#__PURE__*/ Prototype({
 		label: "Command",
@@ -30121,7 +30602,7 @@ const Proto$12 = {
 			return getUnsafe(fiber.context, ChildProcessSpawner).spawn(this);
 		}
 	}),
-	[TypeId$25]: TypeId$25
+	[TypeId$26]: TypeId$26
 };
 const makeStandardCommand = (command, args, options) => Object.assign(Object.create(Proto$12), {
 	_tag: "StandardCommand",
@@ -32223,6 +32704,28 @@ function decodeUnknownEffect$1(schema, options) {
 	return options === void 0 ? parser : (input, overrideOptions) => parser(input, mergeParseOptions(options, overrideOptions));
 }
 /**
+* Creates a decoder for `unknown` input that returns an `Option` safely.
+*
+* **When to use**
+*
+* Use when you need a synchronous yes/no decode from untyped input and do not
+* need schema issue details.
+*
+* **Details**
+*
+* The returned function produces `Option.some` with the decoded `Type` on success
+* or `Option.none` on failure, discarding issue details.
+*
+* @see {@link decodeOption} for input already typed as the schema's `Encoded` type
+* @see {@link decodeUnknownResult} for retaining schema issues as data
+*
+* @category decoding
+* @since 3.10.0
+*/
+function decodeUnknownOption$1(schema, options) {
+	return asOption(decodeUnknownEffect$1(schema, options));
+}
+/**
 * Creates an effectful encoder for `unknown` input.
 *
 * **When to use**
@@ -32306,6 +32809,11 @@ function run(ast) {
 function asExit(parser) {
 	return (input, options) => runSyncExit(parser(input, options));
 }
+/** @internal */
+function asOption(parser) {
+	const parserExit = asExit(parser);
+	return (input, options) => getSuccess(parserExit(input, options));
+}
 function asSync(parser) {
 	return (input, options) => runSync(mapErrorEager(parser(input, options), (issue) => new Error(issue.toString(), { cause: issue })));
 }
@@ -32368,9 +32876,9 @@ const recur$1 = /*#__PURE__*/ memoize((ast) => {
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/internal/schema/schema.js
 /** @internal */
-const TypeId$24 = "~effect/Schema/Schema";
+const TypeId$25 = "~effect/Schema/Schema";
 const SchemaProto = {
-	[TypeId$24]: TypeId$24,
+	[TypeId$25]: TypeId$25,
 	pipe() {
 		return pipeArguments(this, arguments);
 	},
@@ -32441,7 +32949,7 @@ function makeReorder(getPriority) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Schema.js
-const TypeId$23 = TypeId$24;
+const TypeId$24 = TypeId$25;
 /**
 * Creates a schema for a **parametric** type (a generic container such as
 * `Array<A>`, `Option<A>`, etc.) by accepting a list of type-parameter schemas
@@ -32597,6 +33105,26 @@ function decodeUnknownEffect(schema, options) {
 */
 const decodeEffect = decodeUnknownEffect;
 /**
+* Decodes an `unknown` input against a schema, returning an `Option` that is
+* `Some` with the decoded value on success or `None` on failure.
+*
+* **When to use**
+*
+* Use when the input type is not statically known and you only need to know
+* whether decoding succeeded.
+*
+* **Details**
+*
+* Prefer this over {@link decodeUnknownExit} or {@link decodeUnknownEffect}
+* when you don't need error details. For typed input use {@link decodeOption}.
+* Options may be provided either when creating the decoder or when applying it;
+* application options override creation options.
+*
+* @category decoding
+* @since 3.10.0
+*/
+const decodeUnknownOption = decodeUnknownOption$1;
+/**
 * Encodes an `unknown` input against a schema, returning an `Effect` that
 * succeeds with the encoded value or fails with a {@link SchemaError}.
 *
@@ -32694,7 +33222,7 @@ const make$35 = make$36;
 * @since 3.10.0
 */
 function isSchema(u) {
-	return hasProperty(u, TypeId$23) && u[TypeId$23] === TypeId$23;
+	return hasProperty(u, TypeId$24) && u[TypeId$24] === TypeId$24;
 }
 /**
 * Creates an exact optional key schema for struct fields. Unlike `optional`,
@@ -33742,7 +34270,7 @@ function makeClass(Inherited, identifier, struct$1, annotations, proto) {
 				disableChecks: true
 			});
 		}
-		static [TypeId$23] = TypeId$23;
+		static [TypeId$24] = TypeId$24;
 		get [ClassTypeId]() {
 			return ClassTypeId;
 		}
@@ -34142,11 +34670,11 @@ function onSerializerEnsureArray(ast) {
 *
 * @since 4.0.0
 */
-const TypeId$22 = "~effect/http/Cookies";
+const TypeId$23 = "~effect/http/Cookies";
 const CookieTypeId = "~effect/http/Cookies/Cookie";
 TaggedError("CookieError");
 const Proto$11 = {
-	[TypeId$22]: TypeId$22,
+	[TypeId$23]: TypeId$23,
 	...BaseProto,
 	toJSON() {
 		return {
@@ -34471,10 +34999,10 @@ const tryDecodeURIComponent = (str) => {
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$21 = /*#__PURE__*/ Symbol.for("~effect/http/Headers");
+const TypeId$22 = /*#__PURE__*/ Symbol.for("~effect/http/Headers");
 const Proto$10 = /*#__PURE__*/ Object.create(null);
 Object.defineProperties(Proto$10, {
-	[TypeId$21]: { value: TypeId$21 },
+	[TypeId$22]: { value: TypeId$22 },
 	[symbolRedactable]: { value(context) {
 		return redact(this, get$9(context, CurrentRedactedNames));
 	} },
@@ -34669,7 +35197,7 @@ const CurrentRedactedNames = /*#__PURE__*/ Reference("effect/Headers/CurrentReda
 *
 * @since 4.0.0
 */
-const TypeId$20 = "~effect/http/HttpClientError";
+const TypeId$21 = "~effect/http/HttpClientError";
 /**
 * Error wrapper for HTTP client failures, exposing the failed request and the optional response through its `reason`.
 *
@@ -34689,7 +35217,7 @@ var HttpClientError = class extends TaggedError("HttpClientError") {
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$20] = TypeId$20;
+	[TypeId$21] = TypeId$21;
 	/**
 	* HTTP request associated with the client failure.
 	*
@@ -34812,7 +35340,7 @@ var EmptyBodyError = class extends TaggedError("EmptyBodyError") {
 		return formatMessage(formatReason(this._tag), this.description, info);
 	}
 };
-ErrorClass(TypeId$20)({
+ErrorClass(TypeId$21)({
 	_tag: /*#__PURE__*/ tag("HttpError"),
 	kind: /*#__PURE__*/ Literals([
 		"EncodeError",
@@ -34864,10 +35392,10 @@ ErrorClass(TypeId$20)({
 *
 * @since 4.0.0
 */
-const TypeId$19 = "~effect/http/UrlParams";
+const TypeId$20 = "~effect/http/UrlParams";
 const Proto$9 = {
 	...PipeInspectableProto,
-	[TypeId$19]: TypeId$19,
+	[TypeId$20]: TypeId$20,
 	[Symbol.iterator]() {
 		return this.params[Symbol.iterator]();
 	},
@@ -35065,12 +35593,12 @@ const baseUrl = () => {
 *
 * @since 4.0.0
 */
-const TypeId$18 = "~effect/http/HttpBody";
+const TypeId$19 = "~effect/http/HttpBody";
 TaggedError("HttpBodyError");
 var Proto$8 = class {
-	[TypeId$18];
+	[TypeId$19];
 	constructor() {
-		this[TypeId$18] = TypeId$18;
+		this[TypeId$19] = TypeId$19;
 	}
 	[NodeInspectSymbol]() {
 		return this.toJSON();
@@ -35297,9 +35825,9 @@ const allShort = [
 ];
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/unstable/http/HttpClientRequest.js
-const TypeId$17 = "~effect/http/HttpClientRequest";
+const TypeId$18 = "~effect/http/HttpClientRequest";
 const Proto$7 = {
-	[TypeId$17]: TypeId$17,
+	[TypeId$18]: TypeId$18,
 	...BaseProto,
 	toJSON() {
 		return {
@@ -35482,7 +36010,7 @@ const setBody$1 = /*#__PURE__*/ dual(2, (self, body) => {
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$16 = "~effect/http/HttpIncomingMessage";
+const TypeId$17 = "~effect/http/HttpIncomingMessage";
 /**
 * Context reference for the optional maximum size allowed when reading an incoming message body.
 *
@@ -35560,7 +36088,7 @@ const inspect = (self, that) => {
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$15 = "~effect/http/HttpClientResponse";
+const TypeId$16 = "~effect/http/HttpClientResponse";
 /**
 * Wraps a Web `Response` and its original `HttpClientRequest` as an `HttpClientResponse`.
 *
@@ -35569,16 +36097,16 @@ const TypeId$15 = "~effect/http/HttpClientResponse";
 */
 const fromWeb$1 = (request, source) => new WebHttpClientResponse(request, source);
 var WebHttpClientResponse = class extends Class$2 {
+	[TypeId$17];
 	[TypeId$16];
-	[TypeId$15];
 	request;
 	source;
 	constructor(request, source) {
 		super();
 		this.request = request;
 		this.source = source;
+		this[TypeId$17] = TypeId$17;
 		this[TypeId$16] = TypeId$16;
-		this[TypeId$15] = TypeId$15;
 	}
 	toJSON() {
 		return inspect(this, {
@@ -35820,7 +36348,7 @@ const w3c = (headers) => {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/unstable/http/HttpClient.js
-const TypeId$14 = "~effect/http/HttpClient";
+const TypeId$15 = "~effect/http/HttpClient";
 /**
 * Service tag for the default outgoing HTTP client service.
 *
@@ -35860,7 +36388,7 @@ const makeWith = (postprocess, preprocess) => {
 	return self;
 };
 const Proto$6 = {
-	[TypeId$14]: TypeId$14,
+	[TypeId$15]: TypeId$15,
 	pipe() {
 		return pipeArguments(this, arguments);
 	},
@@ -35997,8 +36525,8 @@ var InterruptibleResponse = class {
 		this.original = original;
 		this.controller = controller;
 	}
-	[TypeId$15] = TypeId$15;
 	[TypeId$16] = TypeId$16;
+	[TypeId$17] = TypeId$17;
 	applyInterrupt(effect) {
 		return suspend$2(() => {
 			responseRegistry.unregister(this.original);
@@ -36682,14 +37210,14 @@ const make$29 = make$30;
 const ignore = "~effect/ErrorReporter/ignore";
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/unstable/http/HttpServerResponse.js
-const TypeId$13 = "~effect/http/HttpServerResponse";
+const TypeId$14 = "~effect/http/HttpServerResponse";
 /**
 * Returns `true` when the supplied value is an `HttpServerResponse`.
 *
 * @category guards
 * @since 4.0.0
 */
-const isHttpServerResponse = (u) => hasProperty(u, TypeId$13);
+const isHttpServerResponse = (u) => hasProperty(u, TypeId$14);
 /**
 * Creates an empty HTTP response.
 *
@@ -36822,7 +37350,7 @@ const setBody = /*#__PURE__*/ dual(2, (self, body) => makeResponse({
 }));
 const Proto$5 = {
 	...PipeInspectableProto,
-	[TypeId$13]: TypeId$13,
+	[TypeId$14]: TypeId$14,
 	[ignore]: true,
 	toJSON() {
 		return {
@@ -37020,7 +37548,7 @@ const toResponseOrElseDefect = (u, orElse) => {
 *
 * @since 4.0.0
 */
-const TypeId$12 = "~effect/http/HttpServerError";
+const TypeId$13 = "~effect/http/HttpServerError";
 /**
 * Tagged error for failures that occur while handling an HTTP server request.
 *
@@ -37041,7 +37569,7 @@ var HttpServerError = class extends TaggedError("HttpServerError") {
 		});
 		else super(props);
 	}
-	[TypeId$12] = TypeId$12;
+	[TypeId$13] = TypeId$13;
 	stack = `${this.name}: ${this.message}`;
 	get request() {
 		return this.reason.request;
@@ -37317,7 +37845,7 @@ const exitResponse = (exit) => {
 *
 * @since 2.0.0
 */
-const TypeId$11 = "~effect/FiberSet";
+const TypeId$12 = "~effect/FiberSet";
 /**
 * Checks whether a value is a FiberSet.
 *
@@ -37337,9 +37865,9 @@ const TypeId$11 = "~effect/FiberSet";
 * @category refinements
 * @since 2.0.0
 */
-const isFiberSet = (u) => hasProperty(u, TypeId$11);
+const isFiberSet = (u) => hasProperty(u, TypeId$12);
 const Proto$4 = {
-	[TypeId$11]: TypeId$11,
+	[TypeId$12]: TypeId$12,
 	[Symbol.iterator]() {
 		if (this.state._tag === "Closed") return empty$14();
 		return this.state.backing[Symbol.iterator]();
@@ -37518,7 +38046,7 @@ const join = (self) => _await(self.deferred);
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$10 = "~effect/socket/Socket";
+const TypeId$11 = "~effect/socket/Socket";
 /**
 * Service tag for bidirectional socket transports.
 *
@@ -37539,7 +38067,7 @@ const Socket = /*#__PURE__*/ Service("effect/socket/Socket");
 * @since 4.0.0
 */
 const make$27 = (options) => Socket.of({
-	[TypeId$10]: TypeId$10,
+	[TypeId$11]: TypeId$11,
 	runRaw: options.runRaw,
 	run: options.run ?? ((handler, opts) => options.runRaw((data) => typeof data === "string" ? handler(encoder.encode(data)) : data instanceof Uint8Array ? handler(data) : handler(new Uint8Array(data)), opts)),
 	runString: options.runString ?? (options.run ? (handler, opts) => options.run((data) => handler(decoder$1.decode(data)), opts) : (handler, opts) => options.runRaw((data) => typeof data === "string" ? handler(data) : data instanceof Uint8Array ? handler(decoder$1.decode(data)) : handler(decoder$1.decode(new Uint8Array(data))), opts)),
@@ -38786,7 +39314,7 @@ const decodeField = decodeField$1;
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$9 = "~effect/http/Multipart";
+const TypeId$10 = "~effect/http/Multipart";
 const MultipartErrorTypeId = "~effect/http/Multipart/MultipartError";
 /**
 * Error reason carried by a `MultipartError`.
@@ -38861,10 +39389,10 @@ const makeConfig = (headers) => withFiber((fiber) => {
 	});
 });
 var PartBase$1 = class extends Class$2 {
-	[TypeId$9];
+	[TypeId$10];
 	constructor() {
 		super();
-		this[TypeId$9] = TypeId$9;
+		this[TypeId$10] = TypeId$10;
 	}
 };
 const defaultWriteFile = (path, file) => flatMap$2(FileSystem, (fs) => mapError$2(run$1(file.content, fs.sink(path)), (cause) => MultipartError.fromReason("InternalError", cause)));
@@ -38981,7 +39509,7 @@ const FieldMimeTypes = /*#__PURE__*/ Reference("effect/http/Multipart/FieldMimeT
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$8 = "~effect/http/HttpServerRequest";
+const TypeId$9 = "~effect/http/HttpServerRequest";
 /**
 * Service tag for the active server-side HTTP request.
 *
@@ -39637,7 +40165,7 @@ const withLogAddress = (layer) => effectDiscard(logAddress).pipe(provideMerge(la
 *
 * @since 4.0.0
 */
-const TypeId$7 = "~effect/http/HttpRouter";
+const TypeId$8 = "~effect/http/HttpRouter";
 /**
 * Service tag for the HTTP router used while constructing an HTTP application.
 * Route and middleware layers require this service to register themselves with
@@ -39684,7 +40212,7 @@ const make$19 = /*#__PURE__*/ gen(function* () {
 		return void_$1;
 	});
 	return HttpRouter.of({
-		[TypeId$7]: TypeId$7,
+		[TypeId$8]: TypeId$8,
 		prefixed(prefix) {
 			return HttpRouter.of({
 				...this,
@@ -40139,7 +40667,7 @@ var ClientAbort = class extends Service()("effect/rpc/RpcSchema/ClientAbort") {
 };
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/unstable/rpc/Rpc.js
-const TypeId$6 = "~effect/rpc/Rpc";
+const TypeId$7 = "~effect/rpc/Rpc";
 /**
 * Represents server-side metadata for the client associated with an RPC request.
 *
@@ -40169,7 +40697,7 @@ var ServerClient = class {
 	}
 };
 const Proto$3 = {
-	[TypeId$6]: TypeId$6,
+	[TypeId$7]: TypeId$7,
 	pipe() {
 		return pipeArguments(this, arguments);
 	},
@@ -42912,7 +43440,7 @@ const withRun = () => (f) => suspend$2(() => {
 * @category type IDs
 * @since 4.0.0
 */
-const TypeId$5 = "~effect/Stdio";
+const TypeId$6 = "~effect/Stdio";
 /**
 * Service tag for process standard I/O.
 *
@@ -42927,7 +43455,7 @@ const TypeId$5 = "~effect/Stdio";
 * @category services
 * @since 4.0.0
 */
-const Stdio = /*#__PURE__*/ Service(TypeId$5);
+const Stdio = /*#__PURE__*/ Service(TypeId$6);
 /**
 * Creates a `Stdio` service implementation from the provided fields and
 * attaches the `Stdio` type identifier.
@@ -42949,7 +43477,7 @@ const Stdio = /*#__PURE__*/ Service(TypeId$5);
 * @since 4.0.0
 */
 const make$17 = (options) => ({
-	[TypeId$5]: TypeId$5,
+	[TypeId$6]: TypeId$6,
 	...options
 });
 //#endregion
@@ -43247,7 +43775,7 @@ const make$16 = /*#__PURE__*/ fnUntraced(function* (group, options) {
 	}).pipe(provide$3(scope));
 	yield* forkChild(whileLoop({
 		while: constTrue,
-		body: constant(flatMap$2(take$1(disconnects), (clientId) => {
+		body: constant(flatMap$2(take$2(disconnects), (clientId) => {
 			clients.delete(clientId);
 			return server.disconnect(clientId);
 		})),
@@ -44141,7 +44669,7 @@ function trieNodeAt(root, path) {
 }
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Config.js
-const TypeId$4 = "~effect/Config";
+const TypeId$5 = "~effect/Config";
 /**
 * Returns `true` if `u` is a `Config` instance.
 *
@@ -44162,7 +44690,7 @@ const TypeId$4 = "~effect/Config";
 * @category guards
 * @since 2.0.0
 */
-const isConfig = (u) => hasProperty(u, TypeId$4);
+const isConfig = (u) => hasProperty(u, TypeId$5);
 /**
 * Represents the error type produced when config loading or validation fails.
 *
@@ -44206,7 +44734,7 @@ const Proto$1 = {
 			return this.parse(fiber.getRef(ConfigProvider));
 		}
 	}),
-	[TypeId$4]: TypeId$4,
+	[TypeId$5]: TypeId$5,
 	toJSON() {
 		return { _id: "Config" };
 	}
@@ -44315,7 +44843,7 @@ const map = /*#__PURE__*/ dual(2, (self, f) => {
 * @category combinators
 * @since 2.0.0
 */
-const orElse = /*#__PURE__*/ dual(2, (self, that) => {
+const orElse$2 = /*#__PURE__*/ dual(2, (self, that) => {
 	return make$13((provider) => catch_$2(self.parse(provider), (error) => that(error).parse(provider)));
 });
 function isMissingDataOnly(issue) {
@@ -44369,7 +44897,7 @@ function isMissingDataOnly(issue) {
 * @since 2.0.0
 */
 const withDefault = /*#__PURE__*/ dual(2, (self, defaultValue) => {
-	return orElse(self, (err) => {
+	return orElse$2(self, (err) => {
 		if (isSchemaError(err.cause)) {
 			const issue = err.cause.issue;
 			if (isMissingDataOnly(issue)) return succeed(defaultValue);
@@ -48724,13 +49252,13 @@ var NodeHttpIncomingMessage = class extends Class$2 {
 	*
 	* @since 4.0.0
 	*/
-	[TypeId$16];
+	[TypeId$17];
 	source;
 	onError;
 	remoteAddressOverride;
 	constructor(source, onError, remoteAddressOverride) {
 		super();
-		this[TypeId$16] = TypeId$16;
+		this[TypeId$17] = TypeId$17;
 		this.source = source;
 		this.onError = onError;
 		this.remoteAddressOverride = remoteAddressOverride;
@@ -49118,10 +49646,10 @@ const persisted = (source, headers) => toPersisted(stream(source, headers), (pat
 }));
 const convertPart = (part) => part._tag === "Field" ? new FieldImpl(part.info, part.value) : new FileImpl(part);
 var PartBase = class extends Class$2 {
-	[TypeId$9];
+	[TypeId$10];
 	constructor() {
 		super();
-		this[TypeId$9] = TypeId$9;
+		this[TypeId$10] = TypeId$10;
 	}
 };
 var FieldImpl = class extends PartBase {
@@ -49243,7 +49771,7 @@ function convertError(cause) {
 *
 * @since 4.0.0
 */
-const TypeId$3 = "~effect/platform/Crypto";
+const TypeId$4 = "~effect/platform/Crypto";
 /**
 * Service tag for platform cryptography.
 *
@@ -49310,7 +49838,7 @@ const make$10 = (impl) => {
 	};
 	const nextIntUnsafe = () => Math.floor(nextDoubleUnsafe() * (Number.MAX_SAFE_INTEGER - Number.MIN_SAFE_INTEGER + 1)) + Number.MIN_SAFE_INTEGER;
 	return Crypto.of({
-		[TypeId$3]: TypeId$3,
+		[TypeId$4]: TypeId$4,
 		randomBytes,
 		nextDoubleUnsafe,
 		nextIntUnsafe,
@@ -49530,7 +50058,7 @@ const toFileUrl = (path) => try_({
 * @since 4.0.0
 */
 const layer$11 = /* @__PURE__ */ succeed$4(Path$1)({
-	[TypeId$26]: TypeId$26,
+	[TypeId$27]: TypeId$27,
 	...Path,
 	fromFileUrl,
 	toFileUrl
@@ -49606,7 +50134,7 @@ const layer$9 = /* @__PURE__ */ succeed$4(Stdio, /*#__PURE__*/ make$17({
 }));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Terminal.js
-const TypeId$2 = "~effect/platform/Terminal";
+const TypeId$3 = "~effect/platform/Terminal";
 ErrorClass("QuitError")({ _tag: /*#__PURE__*/ tag("QuitError") });
 /**
 * Service tag for command-line input and output services.
@@ -49640,7 +50168,7 @@ const Terminal$1 = /*#__PURE__*/ Service("effect/platform/Terminal");
 */
 const make$8 = (impl) => Terminal$1.of({
 	...impl,
-	[TypeId$2]: TypeId$2
+	[TypeId$3]: TypeId$3
 });
 /**
 * Provides the default process-backed `Terminal` service, ending key input on
@@ -49880,7 +50408,7 @@ const makeUpgradeHandler = (lazyWss, httpEffect, options) => {
 	});
 };
 var ServerRequestImpl = class ServerRequestImpl extends NodeHttpIncomingMessage {
-	[TypeId$8];
+	[TypeId$9];
 	response;
 	upgradeEffect;
 	url;
@@ -49890,7 +50418,7 @@ var ServerRequestImpl = class ServerRequestImpl extends NodeHttpIncomingMessage
 			request: this,
 			cause
 		}) }), remoteAddressOverride);
-		this[TypeId$8] = TypeId$8;
+		this[TypeId$9] = TypeId$9;
 		this.response = response;
 		this.upgradeEffect = upgradeEffect;
 		this.url = url;
@@ -50606,6 +51134,280 @@ const layer$5 = (loggers, options) => effect(CurrentLoggers, withFiber$1(fnUntra
 	for (const logger of loggers) currentLoggers.add(isEffect$1(logger) ? yield* logger : logger);
 	return currentLoggers;
 })));
+const ValueMatcherProto = {
+	["~effect/match/Match/Matcher"]: {
+		_input: identity,
+		_filters: identity,
+		_result: identity,
+		_return: identity
+	},
+	_tag: "ValueMatcher",
+	add(_case) {
+		if (isSuccess$1(this.value)) return this;
+		if (_case._tag === "When" && _case.guard(this.provided) === true) return makeValueMatcher(this.provided, succeed$7(_case.evaluate(this.provided)));
+		else if (_case._tag === "Not" && _case.guard(this.provided) === false) return makeValueMatcher(this.provided, succeed$7(_case.evaluate(this.provided)));
+		return this;
+	},
+	pipe() {
+		return pipeArguments(this, arguments);
+	}
+};
+function makeValueMatcher(provided, value) {
+	const matcher = Object.create(ValueMatcherProto);
+	matcher.provided = provided;
+	matcher.value = value;
+	return matcher;
+}
+const makeWhen = (guard, evaluate) => ({
+	_tag: "When",
+	guard,
+	evaluate
+});
+const makePredicate = (pattern) => {
+	if (typeof pattern === "function") return pattern;
+	else if (Array.isArray(pattern)) {
+		const predicates = pattern.map(makePredicate);
+		const len = predicates.length;
+		return (u) => {
+			if (!Array.isArray(u)) return false;
+			for (let i = 0; i < len; i++) if (predicates[i](u[i]) === false) return false;
+			return true;
+		};
+	} else if (pattern !== null && typeof pattern === "object") {
+		const keysAndPredicates = Object.entries(pattern).map(([k, p]) => [k, makePredicate(p)]);
+		const len = keysAndPredicates.length;
+		return (u) => {
+			if (typeof u !== "object" || u === null) return false;
+			for (let i = 0; i < len; i++) {
+				const [key, predicate] = keysAndPredicates[i];
+				if (!(key in u) || predicate(u[key]) === false) return false;
+			}
+			return true;
+		};
+	}
+	return (u) => u === pattern;
+};
+/** @internal */
+const value$1 = (i) => makeValueMatcher(i, fail$7(i));
+/** @internal */
+const when$1 = (pattern, f) => (self) => self.add(makeWhen(makePredicate(pattern), f));
+/** @internal */
+const orElse$1 = (f) => (self) => {
+	const toResult = result(self);
+	if (isResult(toResult)) return toResult._tag === "Success" ? toResult.success : f(toResult.failure);
+	return (input) => {
+		const a = toResult(input);
+		return isSuccess$1(a) ? a.success : f(a.failure);
+	};
+};
+/** @internal */
+const result = (self) => {
+	if (self._tag === "ValueMatcher") return self.value;
+	const len = self.cases.length;
+	if (len === 1) {
+		const _case = self.cases[0];
+		return (input) => {
+			if (_case._tag === "When" && _case.guard(input) === true) return succeed$7(_case.evaluate(input));
+			else if (_case._tag === "Not" && _case.guard(input) === false) return succeed$7(_case.evaluate(input));
+			return fail$7(input);
+		};
+	}
+	return (input) => {
+		for (let i = 0; i < len; i++) {
+			const _case = self.cases[i];
+			if (_case._tag === "When" && _case.guard(input) === true) return succeed$7(_case.evaluate(input));
+			else if (_case._tag === "Not" && _case.guard(input) === false) return succeed$7(_case.evaluate(input));
+		}
+		return fail$7(input);
+	};
+};
+//#endregion
+//#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Match.js
+/**
+* Pattern matching for TypeScript values, predicates, and tagged unions.
+*
+* `Match` turns branching logic into a matcher that is built from ordered
+* cases and finished with an explicit finalizer. Use `Match.type` to define a
+* reusable matcher for a type, or `Match.value` to classify one value
+* immediately. Cases can match literal values, predicates, object patterns,
+* discriminators, tags, or negated patterns.
+*
+* **Mental model**
+*
+* A matcher checks cases in the order they are added and evaluates the handler
+* for the first match. Type matchers produce a function that can be reused with
+* different inputs, while value matchers already contain the input value. As
+* cases are added, the type system tracks which inputs remain unmatched, so
+* `Match.exhaustive` is only available when every remaining case has been
+* handled.
+*
+* **Common tasks**
+*
+* - Use `Match.type<Union>()` when a branch table should be reusable and
+*   exhaustiveness-checked.
+* - Use `Match.value(value)` when a single value should be matched immediately.
+* - Use `Match.tag`, `Match.tags`, or `Match.discriminator` for discriminated
+*   unions and domain objects with tag fields.
+* - Use `Match.orElse`, `Match.option`, or `Match.result` when unmatched input
+*   should be handled explicitly instead of requiring full exhaustiveness.
+*
+* **Example** (Matching a tagged union)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* type Event =
+*   | { readonly _tag: "UserCreated"; readonly id: string }
+*   | { readonly _tag: "UserDeleted"; readonly id: string }
+*
+* const describe = Match.type<Event>().pipe(
+*   Match.tag("UserCreated", (event) => `created ${event.id}`),
+*   Match.tag("UserDeleted", (event) => `deleted ${event.id}`),
+*   Match.exhaustive
+* )
+* ```
+*
+* @since 4.0.0
+*/
+/**
+* Creates a matcher from a specific value.
+*
+* **When to use**
+*
+* Use to match one concrete input immediately.
+*
+* **Details**
+*
+* This function allows you to define a `Matcher` directly from a given value,
+* rather than from a type. This is useful when working with known values,
+* enabling structured pattern matching on objects, primitives, or any data
+* structure.
+*
+* Once the matcher is created, you can use pattern-matching functions like
+* {@link when} to define how different cases should be handled.
+*
+* **Example** (Matching an Object by Property)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* const input = { name: "John", age: 30 }
+*
+* // Create a matcher for the specific object
+* const result = Match.value(input).pipe(
+*   // Match when the 'name' property is "John"
+*   Match.when(
+*     { name: "John" },
+*     (user) => `${user.name} is ${user.age} years old`
+*   ),
+*   // Provide a fallback if no match is found
+*   Match.orElse(() => "Oh, not John")
+* )
+*
+* console.log(result)
+* // Output: "John is 30 years old"
+* ```
+*
+* @see {@link type} for creating a matcher from a specific type.
+*
+* @category constructors
+* @since 4.0.0
+*/
+const value = value$1;
+/**
+* Defines a condition for matching values.
+*
+* **When to use**
+*
+* Use to add one positive pattern case to a `Match.type` or `Match.value`
+* pipeline when a direct value, predicate, or structured object pattern should
+* run a handler for matching input.
+*
+* **Details**
+*
+* Supports both direct value comparisons and predicate functions. If the
+* pattern matches, the associated function is executed and the matched input is
+* removed from the remaining cases tracked by the matcher.
+*
+* **Example** (Matching with Values and Predicates)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* // Create a matcher for objects with an "age" property
+* const match = Match.type<{ age: number }>().pipe(
+*   // Match when age is greater than 18
+*   Match.when(
+*     { age: (age: number) => age > 18 },
+*     (user: { age: number }) => `Age: ${user.age}`
+*   ),
+*   // Match when age is exactly 18
+*   Match.when({ age: 18 }, () => "You can vote"),
+*   // Fallback case for all other ages
+*   Match.orElse((user: { age: number }) => `${user.age} is too young`)
+* )
+*
+* console.log(match({ age: 20 }))
+* // Output: "Age: 20"
+*
+* console.log(match({ age: 18 }))
+* // Output: "You can vote"
+*
+* console.log(match({ age: 4 }))
+* // Output: "4 is too young"
+* ```
+*
+* @see {@link whenOr} for handling any one of several patterns with the same handler
+* @see {@link whenAnd} for requiring all provided patterns to match before running a handler
+* @see {@link not} for handling inputs that do not match a pattern
+* @see {@link orElse} for providing a fallback when no pattern case matches
+*
+* @category Defining patterns
+* @since 4.0.0
+*/
+const when = when$1;
+/**
+* Provides a fallback value when no patterns match.
+*
+* **When to use**
+*
+* Use to finalize a matcher with a fallback for unmatched input.
+*
+* **Details**
+*
+* This function ensures that a matcher always returns a valid result, even if
+* no defined patterns match. It acts as a default case, similar to the
+* `default` clause in a `switch` statement or the final `else` in an `if-else`
+* chain.
+*
+* **Example** (Providing a Default Value When No Patterns Match)
+*
+* ```ts
+* import { Match } from "effect"
+*
+* // Create a matcher for string or number values
+* const match = Match.type<string | number>().pipe(
+*   // Match when the value is "a"
+*   Match.when("a", () => "ok"),
+*   // Fallback when no patterns match
+*   Match.orElse(() => "fallback")
+* )
+*
+* console.log(match("a"))
+* // Output: "ok"
+*
+* console.log(match("b"))
+* // Output: "fallback"
+* ```
+*
+* @see {@link option} for finalizing unmatched input as `Option.none`
+* @see {@link result} for returning unmatched input as a `Result` failure
+* @see {@link orElseAbsurd} for finalizing when unmatched input should be impossible
+*
+* @category completion
+* @since 4.0.0
+*/
+const orElse = orElse$1;
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.0-beta.74/node_modules/effect/dist/Random.js
 /**
@@ -51490,23 +52292,11 @@ var TerminalError = class extends TaggedErrorClass()("TerminalError", {
 	cause: optional(Defect),
 	message: optional(String$1)
 }) {};
-const TerminalEvent = Union([Struct({
+const TerminalEvent = Struct({
 	data: String$1,
+	sequence: Number$1,
 	type: Literal("data")
-}), Struct({ type: Literal("reset") })]);
-Union([
-	Struct({
-		data: String$1,
-		type: Literal("write")
-	}),
-	Struct({
-		cols: Number$1,
-		rows: Number$1,
-		type: Literal("resize")
-	}),
-	Struct({ type: Literal("restart") }),
-	Struct({ type: Literal("stop") })
-]);
+});
 const TerminalState = Struct({
 	runId: Number$1,
 	state: Literals([
@@ -51514,7 +52304,6 @@ const TerminalState = Struct({
 		"starting",
 		"running",
 		"waiting",
-		"needs_input",
 		"stopped",
 		"exited",
 		"failed"
@@ -51522,15 +52311,12 @@ const TerminalState = Struct({
 	title: String$1
 });
 function terminalStateActive(state) {
-	return state === "idle" || state === "starting" || state === "running" || state === "waiting" || state === "needs_input";
+	return state === "idle" || state === "starting" || state === "running" || state === "waiting";
 }
 const TerminalUpdate = Union([Struct({
 	state: TerminalState,
 	type: Literal("state")
-}), Struct({
-	event: TerminalEvent,
-	type: Literal("event")
-})]);
+}), TerminalEvent]);
 //#endregion
 //#region src/rpcs/contracts.ts
 const TerminalPayload = Struct({
@@ -51740,8 +52526,7 @@ var RpcContracts = class extends make$15(make$18("agents.create", {
 		data: String$1,
 		env: optional(Record(String$1, String$1)),
 		sessionId: optional(String$1)
-	}),
-	success: TerminalState
+	})
 }), make$18("terminal.resize", {
 	error: TerminalError,
 	payload: Struct({
@@ -51752,12 +52537,16 @@ var RpcContracts = class extends make$15(make$18("agents.create", {
 		env: optional(Record(String$1, String$1)),
 		rows: Number$1,
 		sessionId: optional(String$1)
-	}),
-	success: TerminalState
+	})
 }), make$18("terminal.restart", {
 	error: TerminalError,
 	payload: TerminalPayload,
 	success: TerminalState
+}), make$18("terminal.state.watch", {
+	error: TerminalError,
+	payload: TerminalPayload,
+	stream: true,
+	success: TerminalState
 }), make$18("terminal.stop", {
 	error: TerminalError,
 	payload: TerminalPayload,
@@ -52449,6 +53238,7 @@ var GitWorktree = class extends Service()("@deslop/git/service/GitWorktree", { m
 };
 //#endregion
 //#region ../../packages/portless/src/lib/utils.ts
+const PackageJson = Struct({ scripts: optional(Record(String$1, String$1)) });
 function command(script, port) {
 	return make$40("vp", [
 		"run",
@@ -52474,23 +53264,23 @@ const discover = fnUntraced(function* (cwd, input) {
 		"package.json",
 		"**/package.json"
 	], { cwd }));
-	return yield* pipe(pipe(split$1("\n")(output), filter$2((path) => path === "package.json" || endsWith("/package.json")(path))), map$7((packagePath) => pipe(pipe(fs.readFileString(path.join(cwd, packagePath)), map$4((source) => ({
-		packageJson: JSON.parse(source),
-		packagePath
-	})), catch_$2(() => succeed$3(void 0))), flatMap$2((result) => {
-		if (result === void 0) return succeed$3([]);
-		const packageDirectory = result.packagePath === "package.json" ? cwd : path.join(cwd, path.dirname(result.packagePath));
+	return yield* pipe(pipe(split$1("\n")(output), filter$2((path) => path === "package.json" || endsWith("/package.json")(path))), map$7((packagePath) => pipe(fs.readFileString(path.join(cwd, packagePath)), flatMap$2((source) => try_({
+		catch: (error) => error,
+		try: () => pipe(JSON.parse(source), decodeUnknownOption(PackageJson))
+	})), catch_$2(() => succeed$3(none())), flatMap$2((packageJson) => {
+		if (isNone(packageJson)) return succeed$3([]);
+		const packageDirectory = packagePath === "package.json" ? cwd : path.join(cwd, path.dirname(packagePath));
 		const folder = path.basename(packageDirectory);
-		const scriptEntries = pipe(Object.entries(result.packageJson.scripts ?? {}), filter$2((entry) => entry[0] === "dev" || startsWith("dev:")(entry[0])));
-		const packageOrigin = `http://${[
+		const scriptEntries = pipe(Object.entries(packageJson.value.scripts ?? {}), filter$2((entry) => entry[0] === "dev" || startsWith("dev:")(entry[0])));
+		const packageOrigin = input.origin([
 			folder,
 			path.basename(cwd),
 			"localhost"
-		].join(".")}:${input.proxyPort}`;
+		].join("."));
 		return pipe(scriptEntries, map$7((entry) => {
 			const name = entry[0];
 			const scriptCommand = entry[1];
-			return map$4(input.port(`${result.packagePath}:${name}`), (port) => {
+			return map$4(input.port(`${packagePath}:${name}`), (port) => {
 				const service = /^dev:(.+)$/u.exec(name)?.[1] ?? "dev";
 				const host = [
 					service,
@@ -52498,7 +53288,7 @@ const discover = fnUntraced(function* (cwd, input) {
 					path.basename(cwd),
 					"localhost"
 				].join(".");
-				const origin = `http://${host}:${input.proxyPort}`;
+				const origin = input.origin(host);
 				return {
 					host,
 					port,
@@ -52517,9 +53307,9 @@ const discover = fnUntraced(function* (cwd, input) {
 						name,
 						origin,
 						packageFolder: folder,
-						packagePath: result.packagePath,
+						packagePath,
 						service,
-						sessionId: `${result.packagePath}:${name}:${Date.now()}:${Math.random()}`
+						sessionId: `${packagePath}:${name}:${Date.now()}:${Math.random()}`
 					}
 				};
 			});
@@ -52587,9 +53377,9 @@ const INJECTED_HEAD = `<script>
 <\/script>
 <script crossorigin="anonymous" src="//unpkg.com/react-scan/dist/auto.global.js" onload="window.reactScan?.({allowInIframe: true, _debug: 'verbose'})"><\/script>
 <script src="https://unpkg.com/react-grab/dist/index.global.js"><\/script>`;
-const injectScripts = fnUntraced(function* (html) {
+function injectScripts(html) {
 	return /<head[^>]*>/i.test(html) ? html.replace(/<head[^>]*>/i, (match) => `${match}\n${INJECTED_HEAD}`) : `${INJECTED_HEAD}\n${html}`;
-});
+}
 const proxy = fnUntraced(function* (request, origin) {
 	const webRequest = yield* toWeb(request);
 	const [pathname = "/", search = ""] = request.url.split("?");
@@ -52613,7 +53403,7 @@ const proxy = fnUntraced(function* (request, origin) {
 	}));
 	const body = yield* tryPromise(() => upstreamResponse.text());
 	headers.set("content-type", "text/html; charset=utf-8");
-	return fromWeb(new Response(yield* injectScripts(body), {
+	return fromWeb(new Response(injectScripts(body), {
 		headers,
 		status: upstreamResponse.status,
 		statusText: upstreamResponse.statusText
@@ -52621,41 +53411,46 @@ const proxy = fnUntraced(function* (request, origin) {
 });
 const proxyWebSocket = fnUntraced(function* (request, origin) {
 	const [pathname = "/", search = ""] = request.url.split("?");
-	const protocols = request.headers["sec-websocket-protocol"]?.split(",").map((protocol) => protocol.trim()).filter((protocol) => protocol.length > 0);
+	const protocols = pipe(fromUndefinedOr(request.headers["sec-websocket-protocol"]), map$9((protocols) => pipe(protocols, split$1(","), map$7(trim), filter$2(isNonEmpty$1))));
 	const inbound = yield* request.upgrade;
 	const upstreamUrl = new URL(origin);
 	upstreamUrl.protocol = upstreamUrl.protocol === "https:" ? "wss:" : "ws:";
 	upstreamUrl.pathname = pathname;
 	upstreamUrl.search = search;
-	const outbound = yield* makeWebSocket(upstreamUrl.toString(), { protocols }).pipe(provide(layerWebSocketConstructorGlobal));
+	const outbound = yield* makeWebSocket(upstreamUrl.toString(), { protocols: getOrUndefined$1(protocols) }).pipe(provide(layerWebSocketConstructorGlobal));
 	const writeInbound = yield* inbound.writer;
 	const writeOutbound = yield* outbound.writer;
 	yield* outbound.runRaw((message) => writeInbound(message)).pipe(catchReason("SocketError", "SocketCloseError", (reason) => writeInbound(new CloseEvent(reason.code, reason.closeReason)).pipe(catch_$2(() => void_$1))), catch_$2(() => writeInbound(new CloseEvent(1011, "proxy error")).pipe(catch_$2(() => void_$1))), forkScoped);
-	yield* inbound.runRaw((message) => writeOutbound(typeof message === "string" ? message : message.slice())).pipe(catch_$2(() => void_$1), ensuring$2(writeOutbound(new CloseEvent()).pipe(catch_$2(() => void_$1))));
+	yield* inbound.runRaw((message) => writeOutbound(isString(message) ? message : message.slice())).pipe(catch_$2(() => void_$1), ensuring$2(writeOutbound(new CloseEvent()).pipe(catch_$2(() => void_$1))));
 	return empty();
 });
-const requestHostname = fnUntraced(function* (host) {
-	return fromUndefinedOr(host?.split(":")[0]);
-});
+function requestHostname(host) {
+	return pipe(fromUndefinedOr(host), flatMap$6((host) => pipe(host, split$1(":"), head)));
+}
 function isLocalHostname(hostname) {
 	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1" || hostname === "[::1]";
 }
-var Portless = class Portless extends Service()("@deslop/portless/Portless", { make: sync(() => {
+var Portless = class Portless extends Service()("@deslop/portless/Portless", { make: gen(function* () {
+	const server = yield* HttpServer;
+	const proxyPort = server.address._tag === "TcpAddress" ? server.address.port.toString() : yield* die$1(/* @__PURE__ */ new Error("portless requires a TCP HTTP server address"));
 	const ports = /* @__PURE__ */ new Map();
 	const routes = /* @__PURE__ */ new Map();
+	function origin(host) {
+		return `http://${host}:${proxyPort}`;
+	}
 	const middleware = fnUntraced(function* (app) {
 		const request = yield* HttpServerRequest;
-		const hostname = yield* requestHostname(request.headers["host"]);
+		const hostname = requestHostname(request.headers["host"]);
 		if (isNone(hostname) || isLocalHostname(hostname.value)) return yield* app;
 		if (!hostname.value.endsWith(".localhost")) return yield* app;
-		const route = yield* lookup(request.headers["host"]);
+		const route = lookup(request.headers["host"]);
 		if (isNone(route)) return empty({ status: 404 });
 		if (request.headers["upgrade"]?.toLowerCase() === "websocket") return yield* proxyWebSocket(request, route.value);
 		return yield* proxy(request, route.value);
 	});
-	const lookup = fnUntraced(function* (host) {
-		return pipe(yield* requestHostname(host), flatMap$6((hostname) => fromUndefinedOr(routes.get(hostname))));
-	});
+	function lookup(host) {
+		return pipe(requestHostname(host), flatMap$6((hostname) => fromUndefinedOr(routes.get(hostname))));
+	}
 	const port = fnUntraced(function* (key) {
 		const existing = ports.get(key);
 		if (existing !== void 0) return existing;
@@ -52671,15 +53466,13 @@ var Portless = class Portless extends Service()("@deslop/portless/Portless", { m
 	});
 	return {
 		middleware,
-		port,
-		register: fnUntraced(function* (host, port) {
-			routes.set(host, `http://127.0.0.1:${port}`);
-		}),
-		scripts: fnUntraced(function* (cwd, input) {
+		scripts: fnUntraced(function* (cwd) {
 			return yield* pipe(discover(cwd, {
-				port: (sessionId) => port(`${cwd}:${sessionId}`),
-				proxyPort: input.proxyPort
-			}), map$4((routes) => routes.map((route) => ({
+				origin,
+				port: (sessionId) => port(`${cwd}:${sessionId}`)
+			}), tap((discovered) => sync(() => {
+				for (const route of discovered) routes.set(route.host, `http://127.0.0.1:${route.port}`);
+			})), map$4((routes) => routes.map((route) => ({
 				host: route.host,
 				port: route.port,
 				script: {
@@ -52697,24 +53490,94 @@ var Portless = class Portless extends Service()("@deslop/portless/Portless", { m
 };
 //#endregion
 //#region ../../packages/terminal/src/service.ts
-function snapshotEvents(data) {
-	if (data === "") return empty$13();
-	const events = [];
-	for (let index = 0; index < data.length; index += 64 * 1024) events.push({
-		data: data.slice(index, index + 64 * 1024),
-		type: "data"
-	});
-	return events;
-}
+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 eventBacklogCapacity = 512;
+const terminalReset = "\x1Bc";
 function parseTitleSignal(title) {
-	const trimmed = trim(title);
-	if (/^\[\s*[!.]\s*\]\s*Action Required\b/i.test(trimmed)) return {
-		state: "needs_input",
-		title: trimmed.replace(/^\[\s*[!.]\s*\]\s*/i, "") || trimmed
+	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*/i, "").replace(/^π\s*-\s*/i, "").replace(/^\[\s*[^\]]+\s*\]\s*/, "").replace(/^(?:[⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏|/\\-]\s*)+/, "").replace(/^\|\s*/, "").trim() || trimmed;
-	const segment = nextTitle.match(/^(Idle|Ready|Starting|Working|Thinking|Waiting)\b/i)?.[1]?.toLowerCase();
+	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 {
 		state: "idle",
 		title: nextTitle
@@ -52731,7 +53594,7 @@ function parseTitleSignal(title) {
 		state: "running",
 		title: nextTitle
 	};
-	if (isNonEmpty$1(trimmed)) return {
+	if (trimmed !== "") return {
 		state: "idle",
 		title: nextTitle
 	};
@@ -52740,65 +53603,95 @@ function parseTitleSignal(title) {
 		title: ""
 	};
 }
-function completeSignalData(input) {
-	if (input.endsWith("\x1B")) return {
-		complete: input.slice(0, -1),
-		pending: "\x1B"
-	};
-	const start = input.lastIndexOf("\x1B]");
-	if (start === -1) return {
-		complete: input,
-		pending: ""
-	};
-	const tail = input.slice(start);
-	if (tail.includes("\x07") || tail.includes("\x1B\\")) return {
-		complete: input,
-		pending: ""
-	};
+function snapshotEvents(data, sequence) {
+	if (data === "") return empty$13();
+	const events = [];
+	for (let index = 0; index < data.length; index += 256 * 1024) events.push({
+		data: data.slice(index, index + 256 * 1024),
+		sequence,
+		type: "data"
+	});
+	return events;
+}
+function adjacentGroups(items, sameGroup, merge) {
+	return pipe(items, reduce(empty$13(), (groups, item) => {
+		const next = groups;
+		const previous = groups.at(-1);
+		if (!(previous && sameGroup(previous, item))) {
+			next.push(item);
+			return next;
+		}
+		next[next.length - 1] = merge(previous, item);
+		return next;
+	}));
+}
+function queuedDataGroups(items, merge) {
+	return adjacentGroups(items, (previous, item) => previous.generation === item.generation, merge);
+}
+function mergeQueuedData(previous, item) {
 	return {
-		complete: input.slice(0, start),
-		pending: tail
+		data: `${previous.data}${item.data}`,
+		generation: item.generation
 	};
 }
+function queuedWriteGroups(items) {
+	return adjacentGroups(items, (previous, item) => previous.process === item.process, (previous, item) => ({
+		data: `${previous.data}${item.data}`,
+		process: item.process
+	}));
+}
 var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { make: fnUntraced(function* (config) {
 	const dataQueue = yield* unbounded();
-	const events = yield* bounded$1({ capacity: 256 });
+	const screenQueue = yield* unbounded();
+	const writeQueue = yield* unbounded();
+	const resizeQueue = yield* sliding(1);
+	const events = yield* bounded$1({
+		capacity: 1024,
+		replay: eventBacklogCapacity
+	});
 	const lifecycleLock = yield* make$47(1);
 	const screenLock = yield* make$47(1);
-	const sequenceRef = yield* make$38(0);
-	const signalBuffer = yield* make$38("");
+	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 sizeRef = yield* make$38({
 		cols: 120,
 		rows: 32
 	});
 	const shell = yield* string("SHELL").pipe(orElseSucceed(() => "bash"));
-	const processCommand = config.preparedCommand?.command ?? config.command ?? shell;
-	const processArgs = config.preparedCommand?.args ?? config.args ?? [];
-	const autostart = config.command === void 0 && config.preparedCommand === void 0;
+	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,
 		state: autostart ? "starting" : "idle",
 		title: ""
 	});
-	const screen = new (createRequire(import.meta.url)("@xterm/headless")).Terminal({
+	const screen = new HeadlessModule.Terminal({
 		allowProposedApi: true,
 		cols: 120,
 		rows: 32,
 		scrollback: 1e4
 	});
-	const serialize = new (createRequire(import.meta.url)("@xterm/addon-serialize")).SerializeAddon();
+	const serialize = new SerializeModule.SerializeAddon();
+	const progress = new import_addon_progress.ProgressAddon();
 	screen.loadAddon(serialize);
-	const publish$1 = fnUntraced(function* (event) {
+	screen.loadAddon(progress);
+	const publish$1 = fnUntraced(function* (data) {
+		const sequence = yield* updateAndGet(eventSequenceRef, (sequence) => sequence + 1);
 		yield* publish(events, {
-			event,
-			sequence: yield* updateAndGet(sequenceRef, (sequence) => sequence + 1)
+			data,
+			sequence,
+			type: "data"
 		});
+		return sequence;
 	});
 	const requestSnapshot = withPermit(screenLock, gen(function* () {
 		return {
 			data: serialize.serialize({ scrollback: 1e4 }),
-			sequence: yield* get$3(sequenceRef)
+			sequence: yield* get$3(parsedSequenceRef)
 		};
 	}));
 	function setState(state) {
@@ -52807,9 +53700,10 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 			state
 		}));
 	}
-	function setActiveState(state) {
+	function setProgressState(progress) {
 		return update(stateRef, (current) => {
-			if (current.state !== "idle" && current.state !== "starting" && current.state !== "running") return current;
+			if (current.state === "stopped" || current.state === "exited" || current.state === "failed") return current;
+			const state = pipe(progress.state, value, when(0, () => "idle"), when(2, () => "failed"), when(4, () => "waiting"), orElse(() => "running"));
 			return {
 				...current,
 				state
@@ -52831,17 +53725,16 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		state: "starting",
 		title: ""
 	})), andThen(get(stateRef)));
-	function readSignals(data) {
-		for (const match of data.matchAll(/\x1b\](?:0|2);([^\x07\x1b]*)(?:\x07|\x1b\\)/gu)) {
-			const title = match[1];
-			if (title !== void 0) runFork(setTitle(title));
-		}
-		for (const match of data.matchAll(/\x1b\]9;4;([^\x07\x1b]*)(?:\x07|\x1b\\)/gu)) runFork(setActiveState(match[1] === "0" ? "idle" : "running"));
-	}
-	const readBufferedSignals = fnUntraced(function* (data) {
-		const next = completeSignalData(`${yield* get$3(signalBuffer)}${data}`);
-		yield* set$4(signalBuffer, next.pending);
-		readSignals(next.complete);
+	screen.parser.registerOscHandler(0, (title) => {
+		runFork(setTitle(title));
+		return false;
+	});
+	screen.parser.registerOscHandler(2, (title) => {
+		runFork(setTitle(title));
+		return false;
+	});
+	progress.onChange((nextProgress) => {
+		runFork(setProgressState(nextProgress));
 	});
 	const interruptProcess = fnUntraced(function* (subprocess, signal) {
 		yield* sync(() => {
@@ -52855,14 +53748,14 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		yield* sleep("250 millis");
 		yield* interruptProcess(subprocess, "SIGKILL");
 	});
-	const writeScreen = fnUntraced(function* (data) {
+	const writeScreen = fnUntraced(function* (input) {
+		if ((yield* get$3(screenGenerationRef)) !== input.generation) return;
 		yield* withPermit(screenLock, pipe(callback$1((resume) => {
-			screen.write(data, () => {
+			screen.write(input.data, () => {
 				resume(void_$1);
 			});
-		}), andThen(readBufferedSignals(data)), andThen(publish$1({
-			data,
-			type: "data"
+		}), andThen(gen(function* () {
+			if ((yield* get$3(screenGenerationRef)) === input.generation) yield* set$4(parsedSequenceRef, yield* publish$1(input.data));
 		}))));
 	});
 	const clearProcess = fnUntraced(function* (handle) {
@@ -52883,9 +53776,10 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		if (state) yield* setState(state);
 	});
 	const spawnProcess = fnUntraced(function* () {
+		const generation = yield* updateAndGet(screenGenerationRef, (generation) => generation + 1);
 		yield* withPermit(screenLock, pipe(sync(() => {
 			screen.reset();
-		}), andThen(publish$1({ type: "reset" }))));
+		}), andThen(publish$1(terminalReset)), tap((sequence) => set$4(parsedSequenceRef, sequence))));
 		yield* startRun;
 		const size = yield* get$3(sizeRef);
 		const subprocess = yield* try_({
@@ -52898,7 +53792,7 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 				cwd: config.cwd,
 				env: {
 					...process.env,
-					...config.env,
+					...processEnv,
 					TERM: "xterm-256color"
 				},
 				name: "xterm-256color",
@@ -52907,7 +53801,10 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		});
 		const handle = {
 			data: subprocess.onData((data) => {
-				offerUnsafe(dataQueue, data);
+				offerUnsafe(dataQueue, {
+					data,
+					generation
+				});
 			}),
 			exit: subprocess.onExit((event) => {
 				runFork(withPermit(lifecycleLock, gen(function* () {
@@ -52930,18 +53827,25 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 		yield* stopProcess();
 		return yield* spawnProcess();
 	});
-	yield* pipe(fromQueue(dataQueue), runForEach(writeScreen), forkScoped);
+	yield* pipe(fromQueue(dataQueue), groupedWithin(256, millis(8)), runForEach((items) => forEach$1(queuedDataGroups(fromIterable$2(items), mergeQueuedData), (item) => gen(function* () {
+		if ((yield* get$3(screenGenerationRef)) !== item.generation) return;
+		yield* offer(screenQueue, item);
+	}), { discard: true })), forkScoped);
+	yield* pipe(fromQueue(screenQueue), 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(screenQueue),
+		shutdown(writeQueue),
+		shutdown(resizeQueue),
 		sync(() => screen.dispose())
 	], {
 		concurrency: "unbounded",
 		discard: true
 	}));
 	if (autostart) yield* pipe(startProcess(), withPermit(lifecycleLock), catch_$2(() => setState("failed")));
-	const resize = fnUntraced(function* (nextSize) {
+	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);
@@ -52960,56 +53864,65 @@ var Terminal = class extends Service()("@deslop/terminal/service/Terminal", { ma
 			}
 		});
 	});
-	const write = fnUntraced(function* (data) {
-		const process = yield* get$3(processRef);
-		if (!process) return;
+	yield* pipe(fromQueue(resizeQueue), groupedWithin(32, millis(16)), runForEach((items) => pipe(last(fromIterable$2(items)), match$5({
+		onNone: () => void_$1,
+		onSome: resizeProcess
+	}))), forkScoped);
+	const writeProcess = fnUntraced(function* (input) {
+		if ((yield* get$3(processRef)) !== input.process) return;
 		yield* try_({
 			catch: (cause) => new TerminalError({
 				cause,
 				message: "failed to write to terminal"
 			}),
 			try: () => {
-				process.process.write(data);
+				input.process.process.write(input.data);
 			}
 		});
 	});
+	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$2(pending, (event) => event.sequence > snapshot.sequence);
+		const replaySequence = replay.at(-1)?.sequence ?? snapshot.sequence;
 		return pipe(fromIterable$1([
 			{
-				event: { type: "reset" },
-				sequence: snapshot.sequence
+				data: terminalReset,
+				sequence: snapshot.sequence,
+				type: "data"
 			},
-			...map$7(snapshotEvents(snapshot.data), (event) => ({
-				event,
-				sequence: snapshot.sequence
-			})),
-			...filter$2(pending, (event) => event.sequence > snapshot.sequence)
-		]), concat(fromEffectRepeat(take$2(subscription))));
+			...snapshotEvents(snapshot.data, snapshot.sequence),
+			...replay,
+			...filter$2(pending, (event) => event.sequence > replaySequence)
+		]), concat(fromEffectRepeat(take$3(subscription))));
 	})));
-	const updates = merge$1(changes(stateRef).pipe(map$2((state) => ({
+	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.pipe(map$2((published) => ({
-		event: published.event,
-		type: "event"
-	}))));
+	}))), eventsStream);
 	return {
 		resize: fnUntraced(function* (size) {
-			return yield* pipe(resize(size), andThen(get(stateRef)));
+			yield* offer(resizeQueue, size);
 		}),
 		restart: fnUntraced(function* () {
 			return yield* pipe(startProcess(), withPermit(lifecycleLock), catch_$2(() => pipe(setState("failed"), andThen(get(stateRef)))));
 		}),
+		stateUpdates,
 		stop: fnUntraced(function* () {
 			yield* pipe(stopProcess("stopped"), withPermit(lifecycleLock));
 			return yield* get(stateRef);
 		}),
 		updates,
 		write: fnUntraced(function* (data) {
-			return yield* pipe(write(data), andThen(get(stateRef)));
+			if (data === "") return;
+			const process = yield* get$3(processRef);
+			if (process) yield* offer(writeQueue, {
+				data,
+				process
+			});
 		})
 	};
 }) }) {
@@ -53055,11 +53968,11 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 	const portlessWorktrees = yield* make$46({
 		idleTimeToLive: infinity,
 		lookup: fnUntraced(function* (cwd) {
-			const scripts = yield* pipe(portless.scripts(cwd, { proxyPort: process.env["PORT"] ?? "4010" }), mapError$2((cause) => new TerminalError({
+			const scripts = yield* pipe(portless.scripts(cwd), mapError$2((cause) => new TerminalError({
 				cause,
 				message: `failed to discover portless scripts in ${cwd}`
 			})));
-			yield* all(pipe(scripts, map$7((script) => all([portless.register(script.host, script.port), update$1(portlessScripts, (current) => set$2(current, script.script.sessionId, script.script))], { discard: true }))), { discard: true });
+			yield* all(pipe(scripts, map$7((script) => update$1(portlessScripts, (current) => set$2(current, script.script.sessionId, script.script)))), { discard: true });
 			return pipe(scripts, map$7((route) => ({
 				baseOrigin: route.script.baseOrigin,
 				command: route.script.command,
@@ -53079,14 +53992,33 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 		const script = pipe(yield* get$3(portlessScripts), get$1(input.sessionId), getOrUndefined$1);
 		if (script === void 0) return input;
 		return {
+			command: make$40(script.preparedCommand.command, script.preparedCommand.args, {
+				...script.preparedCommand.options,
+				env: script.env
+			}),
 			cwd: script.cwd,
-			env: script.env,
-			preparedCommand: script.preparedCommand,
 			sessionId: script.sessionId
 		};
 	});
+	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 }),
+			cwd: session.cwd,
+			sessionId: session.sessionId
+		};
+		if (typeof session.command === "string") return {
+			command: make$40(session.command),
+			cwd: session.cwd,
+			sessionId: session.sessionId
+		};
+		return {
+			command: session.command,
+			cwd: session.cwd,
+			sessionId: session.sessionId
+		};
+	}
 	const terminal = fnUntraced(function* (input) {
-		return yield* pipe(terminalSession(input), flatMap$2((session) => get$6(terminals, session)));
+		return yield* pipe(terminalSession(input), map$4(terminalSessionInput), flatMap$2((session) => get$6(terminals, session)));
 	});
 	const reviewStateKey = fnUntraced(function* (input) {
 		const root = yield* pipe(fs.realPath(input.cwd), orElseSucceed(() => input.cwd));
@@ -53133,14 +54065,14 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 				cwd: session.cwd,
 				uuid: session.uuid
 			}), session));
-			const terminal = yield* get$6(terminals, TerminalSessionKey.make({
+			const terminal = yield* terminalSession(TerminalSessionKey.make({
 				args: session.args,
 				command: session.command,
 				cwd: session.cwd,
 				sessionId: session.uuid
-			}));
+			})).pipe(map$4(terminalSessionInput), flatMap$2((session) => get$6(terminals, session)));
 			yield* terminal.restart();
-			yield* pipe(terminal.updates, filterMap((update) => update.type === "state" ? succeed$7(update.state.state) : failVoid), filter((state) => state === "exited" || state === "failed" || state === "stopped"), take(1), runDrain, andThen(update(agents, (current) => remove$2(current, AgentSessionKey.make({
+			yield* pipe(terminal.stateUpdates, map$2((state) => state.state), filter((state) => state === "exited" || state === "failed" || state === "stopped"), take(1), runDrain, andThen(update(agents, (current) => remove$2(current, AgentSessionKey.make({
 				cwd: session.cwd,
 				uuid: session.uuid
 			})))), forkDetach);
@@ -53208,6 +54140,7 @@ const RpcHandlers = RpcContracts.toLayer(gen(function* () {
 			rows: payload.rows
 		}))),
 		"terminal.restart": (payload) => flatMap$2(terminal(TerminalSessionKey.make(payload)), (terminal) => terminal.restart()),
+		"terminal.state.watch": (payload) => unwrap$1(map$4(terminal(TerminalSessionKey.make(payload)), (terminal) => terminal.stateUpdates)),
 		"terminal.stop": (payload) => flatMap$2(terminal(TerminalSessionKey.make(payload)), (terminal) => terminal.stop()),
 		"terminal.watch": (payload) => unwrap$1(map$4(terminal(TerminalSessionKey.make(payload)), (terminal) => terminal.updates)),
 		"terminal.write": (payload) => pipe(terminal(TerminalSessionKey.make(payload)), flatMap$2((terminal) => terminal.write(payload.data)))
@@ -66707,7 +67640,7 @@ var OtelSpan = class {
 		this.links = options.links;
 		this.kind = options.kind;
 		const active = contextApi.active();
-		this.parent = options.root !== true ? orElse$1(options.parent, () => getOtelParent(traceApi, active, options.annotations)) : options.parent;
+		this.parent = options.root !== true ? orElse$3(options.parent, () => getOtelParent(traceApi, active, options.annotations)) : options.parent;
 		this.span = tracer.startSpan(options.name, {
 			startTime: nanosToHrTime(options.startTime),
 			links: options.links.length > 0 ? options.links.map((link) => ({