@deslop/stash 0.1.1060 → 0.1.1062

package/dist/{contracts-B4aEKL_A.mjs → contracts-CoHsVor4.mjs}

@@ -3267,6 +3267,8 @@ const SuccessImpl = function(success) {
 SuccessImpl.prototype = SuccessProto;
 /** @internal */
 const succeed$9 = (success) => new SuccessImpl(success);
+/** @internal */
+const fromOption$3 = /*#__PURE__*/ dual(2, (self, onNone) => isNone$1(self) ? fail$8(onNone()) : succeed$9(self.value));
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/Order.js
 /**
@@ -4270,6 +4272,63 @@ const flatMapNullishOr = /*#__PURE__*/ dual(2, (self, f) => isNone(self) ? none(
 */
 const flatten$2 = /*#__PURE__*/ flatMap$7(identity);
 /**
+* Combines a structure of `Option`s (tuple, struct, or iterable) into a single
+* `Option` containing the unwrapped structure.
+*
+* **When to use**
+*
+* Use when you need to combine multiple `Option` values into one while
+* preserving the input shape, with any `None` making the result `None`.
+*
+* **Details**
+*
+* - Tuple input → `Option` of a tuple with the same length
+* - Struct input → `Option` of a struct with the same keys
+* - Iterable input → `Option` of an `Array`
+* - Any `None` in the input → entire result is `None`
+*
+* **Example** (Combining a tuple and a struct)
+*
+* ```ts import.meta.vitest
+* import { Option } from "effect"
+*
+* const maybeName: Option.Option<string> = Option.some("John")
+* const maybeAge: Option.Option<number> = Option.some(25)
+*
+* //      ┌─── Option<[string, number]>
+* //      ▼
+* const tuple = Option.all([maybeName, maybeAge]) // => Option.some(["John", 25])
+*
+* //      ┌─── Option<{ name: string; age: number; }>
+* //      ▼
+* const struct = Option.all({ name: maybeName, age: maybeAge }) // => Option.some({ name: "John", age: 25 })
+* ```
+*
+* @see {@link product} for combining exactly two
+* @see {@link productMany} for a homogeneous collection
+*
+* @stability stable
+* @category combining
+* @since 2.0.0
+*/
+const all$4 = (input) => {
+	if (Symbol.iterator in input) {
+		const out = [];
+		for (const o of input) {
+			if (isNone(o)) return none();
+			out.push(o.value);
+		}
+		return some$1(out);
+	}
+	const out = {};
+	for (const key of Object.keys(input)) {
+		const o = input[key];
+		if (isNone(o)) return none();
+		assignProperty$1(out, key, o.value);
+	}
+	return some$1(out);
+};
+/**
 * Converts an `Option` into an `Array`.
 *
 * **When to use**
@@ -4521,6 +4580,68 @@ const succeed$8 = succeed$9;
 * @since 4.0.0
 */
 const fail$7 = fail$8;
+/**
+* Provides a pre-built failed `Result` whose failure value is `undefined`.
+*
+* **When to use**
+*
+* Use when you need a failed `Result` value that acts only as a control signal
+* without failure data.
+*
+* **Details**
+*
+* This is equivalent to `Result.fail(undefined)` with type
+* `Result<never, void>`, but reuses a shared `Failure` wrapper instead of
+* allocating one each time.
+*
+* **Example** (Failing without a payload)
+*
+* ```ts import.meta.vitest
+* import { Result } from "effect"
+*
+* Result.failVoid // => Result.fail(undefined)
+* ```
+*
+* @see {@link fail} to create a Failure with a specific value
+*
+* @stability stable
+* @category constructors
+* @since 4.0.0
+*/
+const failVoid = /*#__PURE__*/ fail$7(void 0);
+/**
+* Converts an `Option<A>` into a `Result<A, E>`.
+*
+* **When to use**
+*
+* Use when an existing `Option` should become a `Result`, preserving `Some` as
+* success and turning `None` into a caller-provided failure.
+*
+* **Details**
+*
+* - `Some<A>` becomes `Success<A>`
+* - `None` becomes `Failure<E>` using the provided function
+* - Supports both data-first and data-last (piped) usage
+*
+* **Example** (Converting an Option to a Result)
+*
+* ```ts import.meta.vitest
+* import { Option, Result } from "effect"
+*
+* Result.fromOption(Option.some(1), () => "missing") // => Result.succeed(1)
+*
+* Result.fromOption(Option.none(), () => "missing") // => Result.fail("missing")
+* ```
+*
+* @see {@link getSuccess} to extract the success value as an Option
+* @see {@link getFailure} to extract the failure value as an Option
+* @see {@link fromNullishOr} to build a Result from nullable values
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const fromOption$2 = fromOption$3;
 const try_$2 = (evaluate) => {
 	if (isFunction(evaluate)) try {
 		return succeed$8(evaluate());
@@ -5121,6 +5242,25 @@ const toEntries = /*#__PURE__*/ (/* @__PURE__ */ dual(2, (self, f) => {
 */
 const has$3 = /*#__PURE__*/ dual(2, (self, key) => Object.hasOwn(self, key));
 /**
+* Retrieves a value at a particular key from a record safely, returning it wrapped in an `Option`.
+*
+* **Example** (Getting a value as an Option)
+*
+* ```ts import.meta.vitest
+* import { Option, Record as R } from "effect"
+*
+* const person: Record<string, unknown> = { name: "John Doe", age: 35 }
+*
+* R.get(person, "name") // => Option.some("John Doe")
+* R.get(person, "email") // => Option.none()
+* ```
+*
+* @stability stable
+* @category getters
+* @since 2.0.0
+*/
+const get$6 = /*#__PURE__*/ dual(2, (self, key) => Object.hasOwn(self, key) ? some$1(self[key]) : none());
+/**
 * Maps a record into another record by applying a transformation function to each of its values.
 *
 * **Example** (Mapping record values)
@@ -6286,6 +6426,42 @@ const getSomes = (self) => {
 	return out;
 };
 /**
+* Keeps transformed values for elements where a `Filter` succeeds.
+*
+* **When to use**
+*
+* Use to filter an iterable with a `Result`-returning transformation while
+* discarding failures.
+*
+* **Details**
+*
+* The filter receives `(element, index)`. Failures are discarded.
+*
+* **Example** (Filtering and transforming)
+*
+* ```ts import.meta.vitest
+* import { Array, Result } from "effect"
+*
+* Array.filterMap([1, 2, 3, 4], (n) => n % 2 === 0 ? Result.succeed(n * 10) : Result.failVoid) // => [20, 40]
+* ```
+*
+* @see {@link filter} — keep original elements matching a predicate
+* @see {@link partition} for keeping both successes and failures
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const filterMap = /*#__PURE__*/ dual(2, (self, f) => {
+	const as = fromIterable$6(self);
+	const out = [];
+	for (let i = 0; i < as.length; i++) {
+		const result = f(as[i], i);
+		if (isSuccess$1(result)) out.push(result.success);
+	}
+	return out;
+});
+/**
 * Keeps only elements satisfying a predicate (or refinement).
 *
 * **When to use**
@@ -9890,9 +10066,11 @@ const provideServiceImpl = (self, service, implementation) => updateContext$1(se
 /** @internal */
 const zipWith$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[1]), (self, that, f, options) => options?.concurrent ? map$5(all$2([self, that], { concurrency: 2 }), ([a, a2]) => f(a, a2)) : flatMap$4(self, (a) => map$5(that, (a2) => f(a, a2))));
 /** @internal */
+const filterOrFail$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, predicate, orFailWith) => filterOrElse(self, predicate, orFailWith ? (a) => fail$6(orFailWith(a)) : () => fail$6(new NoSuchElementError())));
+/** @internal */
 const when$1 = /*#__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({
+const forever$2 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, options) => whileLoop$1({
 	while: constTrue,
 	body: constant(options?.disableYield ? self : flatMap$4(self, (_) => yieldNow$1)),
 	step: constVoid
@@ -10005,6 +10183,11 @@ const ignoreCause$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, o
 	});
 });
 /** @internal */
+const option$2 = (self) => match$2(self, {
+	onFailure: none,
+	onSuccess: some$1
+});
+/** @internal */
 const result$1 = (self) => matchEager(self, {
 	onFailure: fail$7,
 	onSuccess: succeed$8
@@ -10588,6 +10771,8 @@ const forEachConcurrent = /*#__PURE__*/ iterateConcurrentImpl({
 	}
 });
 /** @internal */
+const filterOrElse = /*#__PURE__*/ dual(3, (self, predicate, orElse) => flatMap$4(self, (a) => predicate(a) ? succeed$7(a) : orElse(a)));
+/** @internal */
 const forkChild$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, options) => withFiber$1((fiber) => {
 	interruptChildrenPatch();
 	return succeed$7(forkUnsafe$1(fiber, self, options?.startImmediately, false, options?.uninterruptible ?? false));
@@ -14609,6 +14794,23 @@ const replace = (searchValue, replaceValue) => (self) => self.replace(searchValu
 */
 const trim = (self) => self.trim();
 /**
+* Removes whitespace from the end of a string.
+*
+* **Example** (Trimming trailing whitespace)
+*
+* ```ts import.meta.vitest
+* import { String } from "effect"
+*
+* String.trimEnd(" a ") // => " a"
+* String.trimEnd("hello world  ") // => "hello world"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const trimEnd = (self) => self.trimEnd();
+/**
 * Extracts a section of a string and returns it as a new string.
 *
 * **Example** (Slicing strings)
@@ -14787,6 +14989,44 @@ const match$1 = (regExp) => (self) => fromNullOr(self.match(regExp));
 * @since 2.0.0
 */
 const padStart = (maxLength, fillString) => (self) => self.padStart(maxLength, fillString);
+/**
+* Repeats the string the specified number of times.
+*
+* **Details**
+*
+* `count` is rounded down. `NaN` and non-positive values are treated as `0`.
+*
+* **Example** (Repeating strings)
+*
+* ```ts import.meta.vitest
+* import { pipe, String } from "effect"
+*
+* pipe("a", String.repeat(5)) // => "aaaaa"
+* pipe("hello", String.repeat(3)) // => "hellohellohello"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const repeat$2 = (count) => (self) => self.repeat(normalize$1(count));
+/**
+* Replaces all occurrences of a substring or pattern in a string.
+*
+* **Example** (Replacing all matches)
+*
+* ```ts import.meta.vitest
+* import { pipe, String } from "effect"
+*
+* pipe("ababb", String.replaceAll("b", "c")) // => "acacc"
+* pipe("ababb", String.replaceAll(/ba/g, "cc")) // => "accbb"
+* ```
+*
+* @stability stable
+* @category transforming
+* @since 2.0.0
+*/
+const replaceAll = (searchValue, replaceValue) => (self) => self.replaceAll(searchValue, replaceValue);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/internal/random.js
 /** @internal */
@@ -15025,6 +15265,28 @@ const ScheduleProto = {
 	}
 };
 /**
+* Type guard that checks if a value is a Schedule.
+*
+* **Example** (Checking for schedules)
+*
+* ```ts import.meta.vitest
+* import { Schedule } from "effect"
+*
+* const schedule = Schedule.exponential("100 millis")
+* const notSchedule = { foo: "bar" }
+*
+* Schedule.isSchedule(schedule) // => true
+* Schedule.isSchedule(notSchedule) // => false
+* Schedule.isSchedule(null) // => false
+* Schedule.isSchedule(undefined) // => false
+* ```
+*
+* @stability stable
+* @category guards
+* @since 2.0.0
+*/
+const isSchedule = (u) => hasProperty(u, TypeId$30);
+/**
 * Creates a Schedule from a step function that returns a Pull.
 *
 * **Example** (Creating a custom schedule from a step function)
@@ -15247,6 +15509,35 @@ const exponential = (base, factor = 2) => {
 	}));
 };
 /**
+* Returns a new `Schedule` that outputs the inputs of the specified schedule.
+*
+* **Example** (Passing inputs through as outputs)
+*
+* ```ts import.meta.vitest
+* import { Effect, Schedule } from "effect"
+*
+* const inputSchedule = Schedule.passthrough(
+*   Schedule.exponential("100 millis").pipe(Schedule.upTo({ times: 3 }))
+* )
+* const program = Effect.gen(function*() {
+*   const step = yield* Schedule.toStep(inputSchedule)
+*   const [output] = yield* step(0, "input")
+*   return output
+* })
+*
+* await Effect.runPromise(program) // => "input"
+* ```
+*
+* @stability stable
+* @category mapping
+* @since 2.0.0
+*/
+const passthrough$2 = (self) => fromStep(map$5(toStep(self), (step) => (now, input) => matchEffect$1(step(now, input), {
+	onSuccess: (result) => succeed$7([input, result[1]]),
+	onFailure: failCause$5,
+	onDone: () => done(input)
+})));
+/**
 * Returns a schedule that recurs continuously, each repetition spaced the
 * specified duration from the last run.
 *
@@ -15277,6 +15568,47 @@ const spaced = (duration) => {
 	const decoded = fromInputUnsafe$1(duration);
 	return fromStepWithMetadata(succeed$7((meta) => succeed$7([meta.attempt - 1, decoded])));
 };
+const while_ = /*#__PURE__*/ dual(2, (self, predicate) => fromStep(map$5(toStep(self), (step) => {
+	const meta = metadataFn();
+	return (now, input) => flatMap$4(step(now, input), (result) => {
+		const [output, duration] = result;
+		const eff = predicate({
+			...meta(now, input),
+			output,
+			duration
+		});
+		return flatMap$4(isEffect$1(eff) ? eff : succeed$7(eff), (check) => check ? succeed$7(result) : done(output));
+	});
+})));
+/**
+* Returns a new `Schedule` that will recur forever.
+*
+* **Details**
+*
+* The output of the schedule is the current count of its repetitions thus far
+* (i.e. `0, 1, 2, ...`).
+*
+* **Example** (Repeating forever)
+*
+* ```ts import.meta.vitest
+* import { Effect, Schedule } from "effect"
+* import { TestClock } from "effect/testing"
+*
+* const executions: Array<number> = []
+* const schedule = Schedule.forever.pipe(Schedule.upTo({ times: 2 }))
+* const program = Effect.sync(() => executions.push(executions.length + 1)).pipe(
+*   Effect.repeat(schedule),
+*   Effect.as(executions)
+* )
+*
+* await Effect.runPromise(Effect.provide(program, TestClock.layer())) // => [1, 2, 3]
+* ```
+*
+* @stability stable
+* @category constructors
+* @since 2.0.0
+*/
+const forever$1 = /*#__PURE__*/ spaced(zero$2);
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/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)));
@@ -15286,6 +15618,13 @@ const provide$1 = /*#__PURE__*/ dual((args) => isEffect$1(args[0]), (self, sourc
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/internal/schedule.js
 const findErrorOnly = (cause) => cause.reasons.every(isFailReason$1) ? findError$1(cause) : fail$7(cause);
 /** @internal */
+const repeatOrElse = /*#__PURE__*/ dual(3, (self, schedule, orElse) => flatMap$4(toStepWithMetadata(schedule), (step) => {
+	let meta = CurrentMetadata.defaultValue();
+	return catchCauseFilter$1(catchDone(forever$2(tap$1(flatMap$4(suspend$3(() => provideService$1(self, CurrentMetadata, meta)), step), (meta_) => sync$2(() => {
+		meta = meta_;
+	})), { disableYield: true }), (out) => succeed$7(out)), findErrorOnly, (error) => orElse(error, meta.attempt === 0 ? none() : some$1(meta)));
+}));
+/** @internal */
 const retryOrElse$1 = /*#__PURE__*/ dual(3, (self, policy, orElse) => flatMap$4(toStepWithMetadata(policy), (step) => {
 	let meta = CurrentMetadata.defaultValue();
 	let lastError;
@@ -15298,6 +15637,31 @@ const retryOrElse$1 = /*#__PURE__*/ dual(3, (self, policy, orElse) => flatMap$4(
 	});
 	return catchDone(loop, (out) => internalCall(() => orElse(lastError, out)));
 }));
+/** @internal */
+const repeat$1 = /*#__PURE__*/ dual(2, (self, options) => {
+	const schedule = typeof options === "function" ? options(identity) : isSchedule(options) ? options : buildFromOptions(options);
+	return repeatOrElse(self, schedule, fail$6);
+});
+/** @internal */
+const retry$1 = /*#__PURE__*/ dual(2, (self, options) => {
+	const schedule = typeof options === "function" ? options(identity) : isSchedule(options) ? options : buildFromOptions(options);
+	return retryOrElse$1(self, schedule, fail$6);
+});
+const passthroughForever = /*#__PURE__*/ passthrough$2(forever$1);
+/** @internal */
+const buildFromOptions = (options) => {
+	let schedule = options.schedule ? passthrough$2(options.schedule) : passthroughForever;
+	if (options.while) schedule = while_(schedule, ({ input }) => {
+		const applied = options.while(input);
+		return isEffect$1(applied) ? applied : succeed$7(applied);
+	});
+	if (options.until) schedule = while_(schedule, ({ input }) => {
+		const applied = options.until(input);
+		return isEffect$1(applied) ? map$5(applied, (b) => !b) : succeed$7(!applied);
+	});
+	if (options.times !== void 0) schedule = while_(schedule, ({ attempt }) => succeed$7(attempt <= options.times));
+	return schedule;
+};
 //#endregion
 //#region ../../node_modules/.pnpm/effect@4.0.2/node_modules/effect/dist/Effect.js
 /**
@@ -16498,6 +16862,49 @@ const tap = tap$1;
 */
 const result = result$1;
 /**
+* Converts success to `Option.some` and failure to `Option.none`.
+*
+* **When to use**
+*
+* Use when you only care whether an effect succeeds and want recoverable
+* failures represented as `Option.none`.
+*
+* **Details**
+*
+* Success values become `Option.some`, recoverable failures become
+* `Option.none`, and defects still fail the effect.
+*
+* **Gotchas**
+*
+* `option` only captures typed, recoverable failures as `Option.none`.
+* Defects and interruptions are not captured inside the `Option` and still
+* fail the effect.
+*
+* `option` also discards typed failure values. Use `result` if the failure
+* value matters.
+*
+* **Example** (Capturing success or failure as Option)
+*
+* ```ts import.meta.vitest
+* import { Effect, Option } from "effect"
+*
+* const program = Effect.all([
+*   Effect.option(Effect.succeed(1)),
+*   Effect.option(Effect.fail("missing"))
+* ])
+*
+* Effect.runSync(program) // => [Option.some(1), Option.none()]
+* ```
+*
+* @see {@link result} for a version that uses `Result` instead.
+* @see {@link exit} for a version that encapsulates both recoverable errors and defects in an `Exit`.
+*
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const option$1 = option$2;
+/**
 * Transforms an effect to encapsulate both failure and success using the `Exit`
 * data type.
 *
@@ -17214,6 +17621,59 @@ const tapError = tapError$1;
 */
 const tapCause = tapCause$1;
 /**
+* Retries typed failures from an effect according to a retry policy.
+*
+* **When to use**
+*
+* Use when you need to rerun an effect after transient typed failures, such as
+* network issues or temporary resource unavailability.
+*
+* **Details**
+*
+* The policy can be a `Schedule`, a schedule builder, or a `Retry.Options`
+* object using `schedule`, `times`, `while`, or `until`. If a retry eventually
+* succeeds, the returned effect succeeds with that value. If the policy stops
+* while the effect is still failing, the last failure is propagated.
+*
+* **Gotchas**
+*
+* The source effect is always evaluated once before any retry policy is
+* applied. For example, `Schedule.recurs(3)` allows up to three retries after
+* the initial attempt.
+*
+* Defects and interruptions are not retried.
+*
+* **Example** (Retrying with a schedule)
+*
+* ```ts import.meta.vitest
+* import { Data, Effect, Schedule } from "effect"
+*
+* class AttemptError extends Data.TaggedError("AttemptError")<{ readonly attempt: number }> {}
+*
+* let attempt = 0
+* const task = Effect.callback<string, AttemptError>((resume) => {
+*   attempt++
+*   if (attempt <= 2) {
+*     resume(Effect.fail(new AttemptError({ attempt })))
+*   } else {
+*     resume(Effect.succeed("Success!"))
+*   }
+* })
+*
+* const policy = Schedule.recurs(5)
+* const program = Effect.retry(task, policy)
+*
+* await Effect.runPromise(program) // => "Success!"
+* ```
+*
+* @see {@link retryOrElse} for a version that allows you to run a fallback.
+* @see {@link repeat} if your retry condition is based on successful outcomes rather than errors.
+* @stability stable
+* @category error handling
+* @since 2.0.0
+*/
+const retry = retry$1;
+/**
 * Retries a failing effect and runs a fallback effect if retries are exhausted.
 *
 * **When to use**
@@ -17564,6 +18024,38 @@ const sleep = sleep$1;
 */
 const raceFirst = raceFirst$1;
 /**
+* Filters an effect, failing with a custom error if the predicate fails.
+*
+* **Details**
+*
+* This function applies a predicate to the result of an effect. If the
+* predicate evaluates to `false`, the effect fails with either a custom
+* error (if `orFailWith` is provided) or a `NoSuchElementError`.
+*
+* **Example** (Filtering with a custom failure)
+*
+* ```ts import.meta.vitest
+* import { Effect } from "effect"
+*
+* // An effect that produces a number
+* const program = Effect.succeed(5)
+*
+* // Filter for even numbers, fail for odd numbers
+* const filtered = Effect.filterOrFail(
+*   program,
+*   (n) => n % 2 === 0,
+*   (n) => `Expected even number, got ${n}`
+* )
+*
+* Effect.runSync(Effect.flip(filtered)) // => "Expected even number, got 5"
+* ```
+*
+* @stability stable
+* @category filtering
+* @since 2.0.0
+*/
+const filterOrFail = filterOrFail$1;
+/**
 * Runs an effect conditionally based on the result of an effectful boolean
 * condition.
 *
@@ -18697,7 +19189,89 @@ const uninterruptibleMask = uninterruptibleMask$1;
 * @category repetition
 * @since 2.0.0
 */
-const forever = forever$1;
+const forever = forever$2;
+/**
+* Repeats an effect based on a specified schedule or until the first failure.
+*
+* **When to use**
+*
+* Use to rerun an effect after successful executions.
+*
+* **Details**
+*
+* This function executes an effect repeatedly according to the given schedule.
+* Each repetition occurs after the initial execution of the effect, meaning
+* that the schedule determines the number of additional repetitions. For
+* example, using `Schedule.once` will result in the effect being executed twice
+* (once initially and once as part of the repetition).
+*
+* If the effect succeeds, it is repeated according to the schedule. If it
+* fails, the repetition stops immediately, and the failure is returned.
+*
+* The schedule can also specify delays between repetitions, making it useful
+* for tasks like retrying operations with backoff, periodic execution, or
+* performing a series of dependent actions.
+*
+* You can combine schedules for more advanced repetition logic, such as adding
+* delays, limiting recursions, or dynamically adjusting based on the outcome of
+* each execution.
+*
+* **Gotchas**
+*
+* The source effect is always evaluated once before the schedule is stepped.
+* The schedule controls additional repetitions, not the initial execution.
+*
+* **Example** (Repeating successful effects with a schedule)
+*
+* ```ts import.meta.vitest
+* // Success Example
+* import { Effect, Schedule } from "effect"
+* const output: Array<unknown> = []
+*
+* const action = Effect.sync(() => { output.push("success") })
+* const policy = Schedule.recurs(2)
+* const program = Effect.repeat(action, policy)
+*
+* void output.push(Effect.runSync(program))
+* output // => ["success", "success", "success", 2]
+* ```
+*
+* **Example** (Stopping repetition on failure)
+*
+* ```ts import.meta.vitest
+* // Failure Example
+* import { Effect, Schedule } from "effect"
+* const output: Array<unknown> = []
+*
+* let count = 0
+*
+* // Define a callback effect that simulates an action with possible failures
+* const action = Effect.callback<string, string>((resume) => {
+*   if (count > 1) {
+*     void output.push("failure")
+*     resume(Effect.fail("Uh oh!"))
+*   } else {
+*     count++
+*     void output.push("success")
+*     resume(Effect.succeed("yay!"))
+*   }
+* })
+*
+* const policy = Schedule.recurs(2)
+* const program = Effect.repeat(action, policy)
+*
+* void output.push((await Effect.runPromiseExit(program))._tag)
+* output // => ["success", "success", "failure", "Failure"]
+* ```
+*
+* @see {@link retry} for failure-based repetition
+* @see {@link repeatOrElse} for fallback handling when repetition fails
+*
+* @stability stable
+* @category repetition
+* @since 2.0.0
+*/
+const repeat = repeat$1;
 /**
 * Create a new span for tracing, and automatically close it when the Scope
 * finalizes.
@@ -45826,15 +46400,16 @@ const Capture = Struct({
 const Extraction = Struct({
 	author: String$2,
 	image: Option(String$2),
+	slides: optionalKey(ArraySchema(String$2)),
 	text: String$2,
 	title: String$2,
 	url: String$2,
 	video: optionalKey(String$2)
 });
 const Organization = Struct({
-	body: pipe(String$2, check(isMaxLength(4e3))),
+	body: pipe(String$2, check(isMaxLength(12e3))),
 	screenText: pipe(String$2, check(isMaxLength(4e3))),
-	summary: pipe(String$2, check(isMaxLength(160))),
+	summary: pipe(String$2, check(isMaxLength(300))),
 	tags: pipe(ArraySchema(Tag), check(isMinLength(1), isMaxLength(3))),
 	title: pipe(String$2, check(isMinLength(1), isMaxLength(80))),
 	topics: pipe(String$2, check(isMaxLength(400)))
@@ -45864,4 +46439,4 @@ var RpcContracts = class extends make$7(make$9("notes.watch", {
 	payload: Struct({ id: NoteId })
 })) {};
 //#endregion
-export { Socket as $, match$1 as $a, fromNullishOr as $c, onExit$1 as $i, dual as $l, mkUint8Array as $n, MinimumLogLevel as $o, asSome as $r, ensure as $s, fromInput as $t, withDefault as A, uninterruptible as Aa, has$3 as Ac, fromResult as Ai, toStringUnknown as Al, toEpochMillis as An, effect as Ao, take$1 as Ar, TaggedError$1 as As, TaggedError as At, constPing as B, withSpan as Ba, isFailure$1 as Bc, logFatal as Bi, string$1 as Bl, flatMap as Bn, succeedContext as Bo, interruptAs as Br, getOrUndefined as Bs, encodeUnknownEffect as Bt, Redacted as C, tapError as Ca, reverse as Cc, fnUntraced as Ci, assignProperty$1 as Cl, toArrayBuffer as Cn, isNoSuchElementError as Co, failCause$1 as Cr, DisablePropagation as Cs, Literal as Ct, option as D, transposeOption as Da, takeRight as Dc, forkIn as Di, Class$2 as Dl, ChildProcessSpawner as Dn, squash as Do, offerUnsafe as Dr, make$34 as Ds, Record as Dt, map as E, timeoutOrElse as Ea, take$3 as Ec, forkChild as Ei, BaseProto as El, make$18 as En, prettyErrors as Eo, offerAll as Er, externalSpan as Es, NullOr as Et, layerJson as F, whileLoop as Fa, make$37 as Fc, interruptible as Fi, array as Fl, decodeText$1 as Fn, merge$3 as Fo, set$2 as Fr, Reference as Fs, decodeEffect as Ft, ClientAbort as G, catchDone as Ga, succeed$8 as Gc, mapEager as Gi, isTagged as Gl, fromQueue as Gn, close as Go, gibibytes as Gr, merge$4 as Gs, tag as Gt, ServerClient as H, exponential as Ha, isSuccess$1 as Hc, logWarning as Hi, hasProperty as Hl, fromChannel as Hn, Scope as Ho, badArgument as Hr, getUnsafe as Hs, is as Ht, layerSchemaBinary as I, withFiber as Ia, fail$7 as Ic, isEffect as Ii, combine$2 as Il, empty$4 as In, mergeAll$1 as Io, makeUnsafe$2 as Ir, Service as Is, decodeSync as It, spanAttributes as J, endsWith as Ja, exists as Jc, matchCauseEffect as Ji, constFalse$1 as Jl, limitBytes as Jn, make$33 as Jo, acquireRelease as Jr, contains as Js, toJsonSchemaDocument as Jt, getStreamSchemas as K, isDoneCause as Ka, try_$2 as Kc, mapError$2 as Ki, isUndefined as Kl, fromReadableStream as Kn, closeUnsafe as Ko, mebibytes as Kr, Prototype as Ks, toCodecJson as Kt, RequestId as L, withFiberSucceed as La, flatMap$6 as Lc, log as Li, hash as Ll, ensuring as Ln, provide$2 as Lo, getCurrent as Lr, add as Ls, decodeUnknownEffect as Lt, withRun as M, updateContext as Ma, map$7 as Mc, ignore as Mi, redact$1 as Ml, Path$1 as Mn, effectDiscard as Mo, publishUnsafe as Mr, parts as Ms, Tuple as Mt, withRunClient as N, useSpan as Na, toEntries as Nc, ignoreCause as Ni, equals$1 as Nl, FileSystem as Nn, empty$7 as No, unbounded as Nr, seconds as Ns, Union as Nt, succeed as O, tryPromise as Oa, assignProperty as Oc, forkScoped as Oi, NodeInspectSymbol as Ol, encode as On, CurrentMemoMap as Oo, shutdown as Or, nativeTracer as Os, String$2 as Ot, RpcSerialization as P, void_$1 as Pa, empty$11 as Pc, interrupt$1 as Pi, symbol$1 as Pl, concat as Pn, launch as Po, make$29 as Pr, toMillis as Ps, Unknown as Pt, CloseEvent as Q, length as Qa, flatten$2 as Qc, onError as Qi, constant as Ql, mkString as Qn, CurrentLogSpans as Qo, as as Qr, empty$9 as Qs, empty as Qt, ResponseDefectEncoded as R, withLogSpan as Ra, getOrElse as Rc, logDebug as Ri, number$1 as Rl, fail$1 as Rn, provideMerge as Ro, interrupt as Rr, empty$8 as Rs, encodeEffect as Rt, Port as S, tapCause as Sa, reduce as Sc, fn as Si, withFiber$1 as Sl, pipeThroughDuplex as Sn, interruptors as So, end as Sr, sync$2 as Ss, Finite as St, URL$1 as T, timeoutOption as Ta, sort as Tc, forever as Ti, setStackTraceLimit as Tl, fromWritable as Tn, map$4 as To, offer as Tr, Tracer as Ts, NonEmptyArray as Tt, exitSchema as U, min as Ua, map$8 as Uc, makeSpanScoped as Ui, isNotUndefined as Ul, fromIterable$5 as Un, addFinalizer$1 as Uo, fromInput$2 as Ur, make$36 as Us, optional as Ut, constPong as V, zipWith as Va, isResult as Vc, logInfo as Vi, symbol$2 as Vl, fromArray as Vn, unwrap$4 as Vo, runIn as Vr, getOrUndefinedUnsafe as Vs, fromJsonString as Vt, isWrapper as W, spaced as Wa, match$5 as Wc, map$3 as Wi, isObject as Wl, fromPubSub as Wn, addFinalizerExit as Wo, fromInputUnsafe as Wr, makeUnsafe$6 as Ws, optionalKey as Wt, Collector as X, isEmpty$1 as Xa, flatMap$7 as Xc, matchEffect as Xi, constUndefined as Xl, mapAccum as Xn, provide$3 as Xo, andThen as Xr, dedupeAdjacentWith as Xs, omit as Xt, spanName as Y, includes as Ya, filter$4 as Yc, matchCauseEffectEager as Yi, constTrue as Yl, map$1 as Yn, makeUnsafe$4 as Yo, all$1 as Yr, dedupe as Ys, isSchemaError$1 as Yt, makeCollectorUnsafe as Z, isNonEmpty as Za, flatMapNullishOr as Zc, never$1 as Zi, constVoid as Zl, mapError as Zn, CurrentLogAnnotations as Zo, annotateLogs as Zr, drop as Zs, encodeUnknownEffect$1 as Zt, QuitError as _, serviceOption as _a, last as _c, exit as _i, flip$1 as _l, fromSetCookie as _n, findError as _o, mkUint8Array$1 as _r, fiberEnterUninterruptibleUnsafe as _s, BooleanLiterals as _t, ImageType as a, provide as aa, flatMap$5 as ac, catchDefect as ai, isSome as al, CurrentRedactedNames as an, toLowerCase as ao, runHead as ar, isExit as as, layerWebSocket as at, layer$8 as b, suspend$2 as ba, match$4 as bc, flatMap$2 as bi, contA as bl, toSetCookieHeaders as bn, hasInterrupts as bo, bounded as br, onExitUnsafe as bs, Exit as bt, NotesError as c, raceFirst as ca, getSomes as cc, catchReason as ci, map$9 as cl, fromRecordUnsafe as cn, parse as co, succeed$2 as cr, succeed$6 as cs, EmptyBodyError as ct, layer as d, runFork as da, head as dc, catch_$1 as di, orElse as dl, remove$1 as dn, Done as do, toReadableStreamEffect as dr, into as ds, HttpClientErrorSchema as dt, onExitPrimitive as ea, every$1 as ec, asVoid as ei, fromUndefinedOr as el, setAll as en, padStart as eo, orDie as er, TracerTimingEnabled as es, SocketError as et, flow as eu, make as f, runForkWith as fa, headNonEmpty as fc, context as fi, some$1 as fl, set$1 as fn, StackTrace as fo, toReadableStreamWith as fr, isDeferred as fs, InvalidUrlError as ft, layer$1 as g, service as ga, join$1 as gc, ensuring$2 as gi, combine$1 as gl, empty$3 as gn, filterInterruptors as go, mapError$1 as gr, fiberEnterInterruptibleUnsafe as gs, ArraySchema as gt, errorReported as h, scoped as ha, isReadonlyArrayNonEmpty as hc, die$1 as hi, String$6 as hl, value as hn, done as ho, fromTransform$1 as hr, effectIsExit as hs, Any as ht, FileType as i, promise as ia, findLast as ic, catchCauseIf as ii, isNone as il, get as in, startsWith as io, runForEachArray as ir, interrupt$2 as is, fromWebSocket as it, Stdio as j, uninterruptibleMask as ja, keys$1 as jc, gen as ji, format$2 as jl, defaultFormatter as jn, effectContext as jo, takeAll as jr, taggedEnum as js, TrueLiterals as jt, unwrap as k, try_ as ka, filter$3 as kc, fromOption as ki, toJson as kl, now as kn, buildWithMemoMap as ko, shutdownUnsafe as kr, Error$2 as ks, Struct as kt, Organization as l, result as la, getUnsafe$1 as lc, catchTag as li, match$6 as ll, isRedactedName as ln, round as lo, suspend as lr, _await as ls, EncodeError as lt, errorExitCode as m, scope as ma, isReadonlyArrayEmpty as mc, delay as mi, Number$5 as ml, make$16 as mn, die$2 as mo, fromPull$1 as mr, ConsoleRef as ms, TransportError as mt, Capture as n, orDie$2 as na, findFirst as nc, callback$1 as ni, getOrNull as nl, has as nn, slice as no, run$1 as nr, fail$5 as ns, SocketOpenError as nt, pipe as nu, Note as o, provideContext$2 as oa, fromIterable$6 as oc, catchFilter as oi, liftPredicate as ol, empty$2 as on, trim as oo, runLast as or, isFailure as os, layerWebSocketConstructorGlobal as ot, runMain as p, runSync$1 as pa, isArray as pc, contextWith as pi, toArray as pl, setAll$1 as pn, combine as po, unwrap$1 as pr, makeUnsafe$5 as ps, StatusCodeError as pt, isStreamSchema as q, Random as qa, contains$1 as qc, match as qi, compose as ql, groupedWithin as qn, forkUnsafe as qo, zero$1 as qr, allocate as qs, toCodecStringTree as qt, Extraction as r, orElseSucceed as ra, findFirstIndex as rc, catchCause$1 as ri, getOrUndefined$1 as rl, fromIterable$2 as rn, split as ro, runForEach as rr, failCause$3 as rs, SocketReadError as rt, pipeArguments as ru, NoteId as s, provideService as sa, get$5 as sc, catchIf as si, liftThrowable as sl, fromInput$1 as sn, max as so, scan as sr, isSuccess as ss, DecodeError as st, RpcContracts as t, onInterrupt as ta, filter$2 as tc, cached as ti, getOrElse$1 as tl, fromIterable as tn, replace as to, pipeThroughChannel as tr, die$3 as ts, SocketErrorReason as tt, identity as tu, LogToStderr as u, retryOrElse as ua, groupBy as uc, catchTags as ui, none as ul, merge as un, Clock as uo, takeUntil as ur, doneUnsafe as us, HttpClientError as ut, Terminal as v, succeed$4 as va, lastNonEmpty as vc, fail$3 as vi, mapInput as vl, isEmpty as vn, fromReasons as vo, make$25 as vr, forkUnsafe$1 as vs, Defect as vt, String$1 as w, timeout as wa, some as wc, forEach$1 as wi, getStackTraceLimit as wl, toUint8Array as wn, makeDieReason as wo, make$26 as wr, ParentSpan as ws, Never as wt, Crypto as x, sync as xa, prepend$1 as xc, flatMapEager as xi, contE as xl, fromReadable as xn, hasInterruptsOnly as xo, collect as xr, reportCauseUnsafe as xs, FalseLiterals as xt, isQuitError as y, succeedNone as ya, map$6 as yc, failCause$2 as yi, PipeInspectableProto as yl, parseHeader as yn, hasDies as yo, makeUnsafe$1 as yr, makeSpanUnsafe as ys, Error$1 as yt, constEof as z, withParentSpan as za, getOrThrow as zc, logError as zi, optimize as zl, filter as zn, succeed$5 as zo, interruptAll as zr, get$4 as zs, encodeSync as zt };
+export { Socket as $, isNonEmpty as $a, match$5 as $c, onExitPrimitive as $i, isNotUndefined as $l, mkUint8Array as $n, make$33 as $o, cached as $r, contains as $s, fromInput as $t, withDefault as A, tryPromise as Aa, some as Ac, gen as Ai, contA as Al, toEpochMillis as An, map$4 as Ao, take$1 as Ar, Tracer as As, TaggedError as At, constPing as B, withLogSpan as Ba, toEntries as Bc, logInfo as Bi, toStringUnknown as Bl, flatMap as Bn, merge$3 as Bo, badArgument as Br, Reference as Bs, encodeUnknownEffect as Bt, Redacted as C, sync as Ca, last as Cc, forEach$1 as Ci, toArray as Cl, toArrayBuffer as Cn, fromReasons as Co, failCause$1 as Cr, forkUnsafe$1 as Cs, Literal as Ct, option as D, timeoutOption as Da, prepend$1 as Dc, forkScoped as Di, flip$1 as Dl, ChildProcessSpawner as Dn, interruptors as Do, offerUnsafe as Dr, sync$2 as Ds, Record as Dt, map as E, timeout as Ea, match$4 as Ec, forkIn as Ei, combine$1 as El, make$18 as En, hasInterruptsOnly as Eo, offerAll as Er, reportCauseUnsafe as Es, NullOr as Et, layerJson as F, useSpan as Fa, filter$3 as Fc, isEffect as Fi, setStackTraceLimit as Fl, decodeText$1 as Fn, effect as Fo, getCurrent as Fr, TaggedError$1 as Fs, decodeEffect as Ft, ClientAbort as G, min as Ga, flatMap$6 as Gc, mapError$2 as Gi, array as Gl, fromQueue as Gn, succeedContext as Go, zero$1 as Gr, getOrUndefined as Gs, tag as Gt, ServerClient as H, withSpan as Ha, make$37 as Hc, makeSpanScoped as Hi, redact$1 as Hl, fromChannel as Hn, provide$2 as Ho, fromInputUnsafe as Hr, add as Hs, is as Ht, layerSchemaBinary as I, void_$1 as Ia, get$6 as Ic, log as Ii, BaseProto as Il, empty$4 as In, effectContext as Io, interrupt as Ir, taggedEnum as Is, decodeSync as It, spanAttributes as J, isDoneCause as Ja, getOrThrow as Jc, matchCauseEffectEager as Ji, number$1 as Jl, limitBytes as Jn, addFinalizer$1 as Jo, andThen as Jr, make$36 as Js, toJsonSchemaDocument as Jt, getStreamSchemas as K, spaced as Ka, fromOption$2 as Kc, match as Ki, combine$2 as Kl, fromReadableStream as Kn, unwrap$4 as Ko, acquireRelease as Kr, getOrUndefinedUnsafe as Ks, toCodecJson as Kt, RequestId as L, whileLoop as La, has$3 as Lc, logDebug as Li, Class$2 as Ll, ensuring as Ln, effectDiscard as Lo, interruptAll as Lr, parts as Ls, decodeUnknownEffect as Lt, withRun as M, uninterruptible as Ma, take$3 as Mc, ignoreCause as Mi, withFiber$1 as Ml, Path$1 as Mn, squash as Mo, publishUnsafe as Mr, make$34 as Ms, Tuple as Mt, withRunClient as N, uninterruptibleMask as Na, takeRight as Nc, interrupt$1 as Ni, assignProperty$1 as Nl, FileSystem as Nn, CurrentMemoMap as No, unbounded as Nr, nativeTracer as Ns, Union as Nt, succeed as O, timeoutOrElse as Oa, reduce as Oc, fromOption as Oi, mapInput as Ol, encode as On, isNoSuchElementError as Oo, shutdown as Or, DisablePropagation as Os, String$2 as Ot, RpcSerialization as P, updateContext as Pa, assignProperty as Pc, interruptible as Pi, getStackTraceLimit as Pl, concat as Pn, buildWithMemoMap as Po, makeUnsafe$2 as Pr, Error$2 as Ps, Unknown as Pt, CloseEvent as Q, isEmpty$1 as Qa, map$8 as Qc, onExit$1 as Qi, hasProperty as Ql, mkString as Qn, forkUnsafe as Qo, asVoid as Qr, allocate as Qs, empty as Qt, ResponseDefectEncoded as R, withFiber as Ra, keys$1 as Rc, logError as Ri, NodeInspectSymbol as Rl, fail$1 as Rn, empty$7 as Ro, interruptAs as Rr, seconds as Rs, encodeEffect as Rt, Port as S, suspend$2 as Sa, join$1 as Sc, fnUntraced as Si, some$1 as Sl, pipeThroughDuplex as Sn, findError as So, end as Sr, fiberEnterUninterruptibleUnsafe as Ss, Finite as St, URL$1 as T, tapError as Ta, map$6 as Tc, forkChild as Ti, String$6 as Tl, fromWritable as Tn, hasInterrupts as To, offer as Tr, onExitUnsafe as Ts, NonEmptyArray as Tt, exitSchema as U, zipWith as Ua, fail$7 as Uc, map$3 as Ui, equals$1 as Ul, fromIterable$5 as Un, provideMerge as Uo, gibibytes as Ur, empty$8 as Us, optional as Ut, constPong as V, withParentSpan as Va, empty$11 as Vc, logWarning as Vi, format$2 as Vl, fromArray as Vn, mergeAll$1 as Vo, fromInput$2 as Vr, Service as Vs, fromJsonString as Vt, isWrapper as W, exponential as Wa, failVoid as Wc, mapEager as Wi, symbol$1 as Wl, fromPubSub as Wn, succeed$5 as Wo, mebibytes as Wr, get$4 as Ws, optionalKey as Wt, Collector as X, endsWith as Xa, isResult as Xc, never$1 as Xi, string$1 as Xl, mapAccum as Xn, close as Xo, as as Xr, merge$4 as Xs, omit as Xt, spanName as Y, Random as Ya, isFailure$1 as Yc, matchEffect as Yi, optimize as Yl, map$1 as Yn, addFinalizerExit as Yo, annotateLogs as Yr, makeUnsafe$6 as Ys, isSchemaError$1 as Yt, makeCollectorUnsafe as Z, includes as Za, isSuccess$1 as Zc, onError as Zi, symbol$2 as Zl, mapError as Zn, closeUnsafe as Zo, asSome as Zr, Prototype as Zs, encodeUnknownEffect$1 as Zt, QuitError as _, scoped as _a, head as _c, failCause$2 as _i, liftThrowable as _l, fromSetCookie as _n, StackTrace as _o, mkUint8Array$1 as _r, isDeferred as _s, BooleanLiterals as _t, ImageType as a, provide as aa, every$1 as ac, catchIf as ai, filter$4 as al, CurrentRedactedNames as an, replaceAll as ao, runHead as ar, TracerTimingEnabled as as, layerWebSocket as at, constTrue as au, layer$8 as b, succeed$4 as ba, isReadonlyArrayEmpty as bc, flatMapEager as bi, none as bl, toSetCookieHeaders as bn, done as bo, bounded as br, effectIsExit as bs, Exit as bt, NotesError as c, raceFirst as ca, findFirst as cc, catchTags as ci, flatten$2 as cl, fromRecordUnsafe as cn, startsWith as co, succeed$2 as cr, failCause$3 as cs, EmptyBodyError as ct, constant as cu, layer as d, retry as da, flatMap$5 as dc, contextWith as di, getOrElse$1 as dl, remove$1 as dn, trimEnd as do, toReadableStreamEffect as dr, isFailure as ds, HttpClientErrorSchema as dt, identity as du, onInterrupt as ea, dedupe as ec, callback$1 as ei, succeed$8 as el, setAll as en, length as eo, orDie as er, makeUnsafe$4 as es, SocketError as et, isObject as eu, make as f, retryOrElse as fa, fromIterable$6 as fc, delay as fi, getOrNull as fl, set$1 as fn, max as fo, toReadableStreamWith as fr, isSuccess as fs, InvalidUrlError as ft, pipe as fu, layer$1 as g, scope as ga, groupBy as gc, fail$3 as gi, liftPredicate as gl, empty$3 as gn, Done as go, mapError$1 as gr, into as gs, ArraySchema as gt, errorReported as h, runSync$1 as ha, getUnsafe$1 as hc, exit as hi, isSome as hl, value as hn, Clock as ho, fromTransform$1 as hr, doneUnsafe as hs, Any as ht, FileType as i, promise as ia, ensure as ic, catchFilter as ii, exists as il, get as in, replace as io, runForEachArray as ir, MinimumLogLevel as is, fromWebSocket as it, constFalse$1 as iu, Stdio as j, try_ as ja, sort as jc, ignore as ji, contE as jl, defaultFormatter as jn, prettyErrors as jo, takeAll as jr, externalSpan as js, TrueLiterals as jt, unwrap as k, transposeOption as ka, reverse as kc, fromResult as ki, PipeInspectableProto as kl, now as kn, makeDieReason as ko, shutdownUnsafe as kr, ParentSpan as ks, Struct as kt, Organization as l, repeat as la, findFirstIndex as lc, catch_$1 as li, fromNullishOr as ll, isRedactedName as ln, toLowerCase as lo, suspend as lr, interrupt$2 as ls, EncodeError as lt, dual as lu, errorExitCode as m, runForkWith as ma, getSomes as mc, ensuring$2 as mi, isNone as ml, make$16 as mn, round as mo, fromPull$1 as mr, _await as ms, TransportError as mt, Capture as n, orDie$2 as na, drop as nc, catchCauseIf as ni, all$4 as nl, has as nn, padStart as no, run$1 as nr, CurrentLogAnnotations as ns, SocketOpenError as nt, isUndefined as nu, Note as o, provideContext$2 as oa, filter$2 as oc, catchReason as oi, flatMap$7 as ol, empty$2 as on, slice as oo, runLast as or, die$3 as os, layerWebSocketConstructorGlobal as ot, constUndefined as ou, runMain as p, runFork as pa, get$5 as pc, die$1 as pi, getOrUndefined$1 as pl, setAll$1 as pn, parse as po, unwrap$1 as pr, succeed$6 as ps, StatusCodeError as pt, pipeArguments as pu, isStreamSchema as q, catchDone as qa, getOrElse as qc, matchCauseEffect as qi, hash as ql, groupedWithin as qn, Scope as qo, all$1 as qr, getUnsafe as qs, toCodecStringTree as qt, Extraction as r, orElseSucceed as ra, empty$9 as rc, catchDefect as ri, contains$1 as rl, fromIterable$2 as rn, repeat$2 as ro, runForEach as rr, CurrentLogSpans as rs, SocketReadError as rt, compose as ru, NoteId as s, provideService as sa, filterMap as sc, catchTag as si, flatMapNullishOr as sl, fromInput$1 as sn, split as so, scan as sr, fail$5 as ss, DecodeError as st, constVoid as su, RpcContracts as t, option$1 as ta, dedupeAdjacentWith as tc, catchCause$1 as ti, try_$2 as tl, fromIterable as tn, match$1 as to, pipeThroughChannel as tr, provide$3 as ts, SocketErrorReason as tt, isTagged as tu, LogToStderr as u, result as ua, findLast as uc, context as ui, fromUndefinedOr as ul, merge as un, trim as uo, takeUntil as ur, isExit as us, HttpClientError as ut, flow as uu, Terminal as v, service as va, headNonEmpty as vc, filterOrFail as vi, map$9 as vl, isEmpty as vn, combine as vo, make$25 as vr, makeUnsafe$5 as vs, Defect as vt, String$1 as w, tapCause as wa, lastNonEmpty as wc, forever as wi, Number$5 as wl, toUint8Array as wn, hasDies as wo, make$26 as wr, makeSpanUnsafe as ws, Never as wt, Crypto as x, succeedNone as xa, isReadonlyArrayNonEmpty as xc, fn as xi, orElse as xl, fromReadable as xn, filterInterruptors as xo, collect as xr, fiberEnterInterruptibleUnsafe as xs, FalseLiterals as xt, isQuitError as y, serviceOption as ya, isArray as yc, flatMap$2 as yi, match$6 as yl, parseHeader as yn, die$2 as yo, makeUnsafe$1 as yr, ConsoleRef as ys, Error$1 as yt, constEof as z, withFiberSucceed as za, map$7 as zc, logFatal as zi, toJson as zl, filter as zn, launch as zo, runIn as zr, toMillis as zs, encodeSync as zt };