affect-cli 0.0.2 → 0.0.4

package/dist/index.js

@@ -510,6 +510,7 @@ function compareHashed(self, that, hashOf, equivalent) {
 var entryHash = (entry) => hash(entry[0]);
 var equalEntries = (self, that) => compareBoth(self[0], that[0]) && compareBoth(self[1], that[1]);
 var isEqual = (u) => hasProperty(u, symbol2) && typeof u[symbol2] === "function";
+var asEquivalence = () => equals;
 
 // node_modules/effect/dist/Redactable.js
 var symbolRedactable = /* @__PURE__ */ Symbol.for("~effect/Redactable");
@@ -746,6 +747,15 @@ var BaseProto = {
   }
 };
 
+class Class2 {
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+}
+
 // node_modules/effect/dist/internal/stackTraceLimit.js
 var isStackTraceLimitWritable = () => {
   const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
@@ -1250,6 +1260,35 @@ var Prototype2 = (options) => makePrimitiveProto({
   [evaluate]: options.evaluate
 });
 
+// node_modules/effect/dist/Equivalence.js
+var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
+var isStrictEquivalent = (x, y) => x === y;
+var strictEqual = () => isStrictEquivalent;
+function Tuple(elements) {
+  return make((self, that) => {
+    if (self.length !== that.length) {
+      return false;
+    }
+    for (let i = 0;i < self.length; i++) {
+      if (!elements[i](self[i], that[i])) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+function Array_(item) {
+  return make((self, that) => {
+    if (self.length !== that.length)
+      return false;
+    for (let i = 0;i < self.length; i++) {
+      if (!item(self[i], that[i]))
+        return false;
+    }
+    return true;
+  });
+}
+
 // node_modules/effect/dist/internal/option.js
 var TypeId = "~effect/Option";
 var CommonProto = {
@@ -1383,11 +1422,11 @@ SuccessImpl.prototype = SuccessProto;
 var succeed = (success) => new SuccessImpl(success);
 
 // node_modules/effect/dist/Order.js
-function make(compare) {
+function make2(compare) {
   return (self, that) => self === that ? 0 : compare(self, that);
 }
-var String2 = /* @__PURE__ */ make((self, that) => self < that ? -1 : 1);
-var Number2 = /* @__PURE__ */ make((self, that) => {
+var String2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
+var Number2 = /* @__PURE__ */ make2((self, that) => {
   if (globalThis.Number.isNaN(self) && globalThis.Number.isNaN(that))
     return 0;
   if (globalThis.Number.isNaN(self))
@@ -1396,7 +1435,7 @@ var Number2 = /* @__PURE__ */ make((self, that) => {
     return 1;
   return self < that ? -1 : 1;
 });
-var mapInput = /* @__PURE__ */ dual(2, (self, f) => make((b1, b2) => self(f(b1), f(b2))));
+var mapInput = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
 var isGreaterThan = (O) => dual(2, (self, that) => O(self, that) === 1);
 
 // node_modules/effect/dist/Option.js
@@ -1457,7 +1496,7 @@ var ServiceProto = {
     return self;
   },
   context(self) {
-    return make2(this, self);
+    return make3(this, self);
   },
   use(f) {
     return withFiber((fiber) => f(get(fiber.context, this)));
@@ -1561,7 +1600,7 @@ var isContext = (u) => hasProperty(u, TypeId3);
 var isReference = (u) => !!u[ReferenceTypeId];
 var empty = () => emptyContext2;
 var emptyContext2 = /* @__PURE__ */ makeUnsafe(/* @__PURE__ */ new Map);
-var make2 = (key, service) => makeUnsafe(new Map([[key.key, service]]));
+var make3 = (key, service) => makeUnsafe(new Map([[key.key, service]]));
 var add = /* @__PURE__ */ dual(3, (self, key, service) => addUnsafe(self, key.key, service));
 var addUnsafe = (self, key, service) => {
   const impl = self;
@@ -1645,6 +1684,22 @@ var normalize = (n) => n > 0 ? Math.floor(n) : 0;
 // node_modules/effect/dist/Result.js
 var succeed2 = succeed;
 var fail2 = fail;
+var failVoid = /* @__PURE__ */ fail2(undefined);
+var try_ = (evaluate) => {
+  if (isFunction(evaluate)) {
+    try {
+      return succeed2(evaluate());
+    } catch (e) {
+      return fail2(e);
+    }
+  } else {
+    try {
+      return succeed2(evaluate.try());
+    } catch (e) {
+      return fail2(evaluate.catch(e));
+    }
+  }
+};
 var isFailure2 = isFailure;
 var isSuccess2 = isSuccess;
 var match2 = /* @__PURE__ */ dual(2, (self, {
@@ -1659,6 +1714,9 @@ var getOrThrowWith = /* @__PURE__ */ dual(2, (self, onFailure) => {
 });
 var getOrThrow = /* @__PURE__ */ getOrThrowWith(identity);
 
+// node_modules/effect/dist/Tuple.js
+var makeEquivalence = Tuple;
+
 // node_modules/effect/dist/Iterable.js
 var findFirst = /* @__PURE__ */ dual(2, (self, f) => {
   let i = 0;
@@ -1700,7 +1758,29 @@ var collect = /* @__PURE__ */ dual(2, (self, f) => {
   return out;
 });
 var toEntries = /* @__PURE__ */ collect((key, value) => [key, value]);
+var has = /* @__PURE__ */ dual(2, (self, key) => Object.hasOwn(self, key));
+var map2 = /* @__PURE__ */ dual(2, (self, f) => {
+  const out = {
+    ...self
+  };
+  for (const key of keys(self)) {
+    assignProperty(out, key, f(self[key], key));
+  }
+  return out;
+});
 var keys = (self) => Object.keys(self);
+var isSubrecordBy = (equivalence) => dual(2, (self, that) => {
+  for (const key of keys(self)) {
+    if (!has(that, key) || !equivalence(self[key], that[key])) {
+      return false;
+    }
+  }
+  return true;
+});
+var makeEquivalence2 = (equivalence) => {
+  const is = isSubrecordBy(equivalence);
+  return (self, that) => is(self, that) && is(that, self);
+};
 
 // node_modules/effect/dist/Array.js
 var Array2 = globalThis.Array;
@@ -1750,11 +1830,42 @@ var sort = /* @__PURE__ */ dual(2, (self, O) => {
   out.sort(O);
   return out;
 });
+var containsWith = (isEquivalent) => dual(2, (self, a) => {
+  for (const i of self) {
+    if (isEquivalent(a, i)) {
+      return true;
+    }
+  }
+  return false;
+});
+var contains = /* @__PURE__ */ containsWith(/* @__PURE__ */ asEquivalence());
 var empty2 = () => [];
 var of = (a) => [a];
-var map2 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var map3 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
+var filterMap = /* @__PURE__ */ dual(2, (self, f) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0;i < as.length; i++) {
+    const result = f(as[i], i);
+    if (isSuccess2(result)) {
+      out.push(result.success);
+    }
+  }
+  return out;
+});
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
+  const as = fromIterable(self);
+  const out = [];
+  for (let i = 0;i < as.length; i++) {
+    if (predicate(as[i], i)) {
+      out.push(as[i]);
+    }
+  }
+  return out;
+});
 var reduce = /* @__PURE__ */ dual(3, (self, b, f) => fromIterable(self).reduce((b, a, i) => f(b, a, i), b));
 var some3 = /* @__PURE__ */ dual(2, (self, predicate) => self.some(predicate));
+var makeEquivalence3 = Array_;
 var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));
 
 // node_modules/effect/dist/Duration.js
@@ -1772,7 +1883,7 @@ var bigintNanosPerDay = /* @__PURE__ */ BigInt(86400000000000);
 var bigintNanosPerWeek = /* @__PURE__ */ BigInt(604800000000000);
 var roundTiesAwayFromZero = (input) => BigInt(Math.sign(input) * Math.round(Math.abs(input)));
 var roundMillisToNanos = (millis) => Number.isInteger(millis) ? BigInt(millis) * bigint1e6 : roundTiesAwayFromZero(millis * 1e6);
-var fromNanosNumber = (nanos) => make3(Number.isFinite(nanos) ? roundTiesAwayFromZero(nanos) : nanos);
+var fromNanosNumber = (nanos) => make4(Number.isFinite(nanos) ? roundTiesAwayFromZero(nanos) : nanos);
 var nanosToUnit = (nanos, divisor) => {
   const value = Number(nanos);
   if (Number.isFinite(value))
@@ -1798,9 +1909,9 @@ var divideTiesAwayFromZero = (numerator, denominator) => {
 var fromMillisString = (input, scale) => {
   const millis = Number(input) * scale;
   if (!Number.isFinite(millis))
-    return make3(millis);
+    return make4(millis);
   const nanos = parseNanos(input, BigInt(scale) * bigint1e6);
-  return make3(Number.isInteger(millis) && BigInt(millis) * bigint1e6 === nanos ? millis : nanos);
+  return make4(Number.isInteger(millis) && BigInt(millis) * bigint1e6 === nanos ? millis : nanos);
 };
 var DURATION_REGEXP = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/;
 var fromInputUnsafe = (input) => {
@@ -1867,7 +1978,7 @@ var fromInputUnsafe = (input) => {
           return infinity;
         }
         const nanos = input[0] * 1e9 + input[1];
-        return Number.isFinite(nanos) && Number.isInteger(input[0]) && Number.isInteger(input[1]) ? make3(BigInt(input[0]) * bigint1e9 + BigInt(input[1])) : fromNanosNumber(nanos);
+        return Number.isFinite(nanos) && Number.isInteger(input[0]) && Number.isInteger(input[1]) ? make4(BigInt(input[0]) * bigint1e9 + BigInt(input[1])) : fromNanosNumber(nanos);
       }
       const obj = input;
       let millis = 0;
@@ -1885,13 +1996,13 @@ var fromInputUnsafe = (input) => {
         millis += obj.milliseconds;
       if (!obj.microseconds && !obj.nanoseconds) {
         if (!Number.isFinite(millis))
-          return make3(millis);
+          return make4(millis);
         const exact = sumObjectNanos(obj);
-        return exact === undefined || BigInt(millis) * bigint1e6 === exact ? make3(millis) : make3(exact);
+        return exact === undefined || BigInt(millis) * bigint1e6 === exact ? make4(millis) : make4(exact);
       }
       const nanos = millis * 1e6 + (obj.microseconds ?? 0) * 1000 + (obj.nanoseconds ?? 0);
       const exact = Number.isFinite(nanos) ? sumObjectNanos(obj) : undefined;
-      return exact === undefined ? fromNanosNumber(nanos) : make3(exact);
+      return exact === undefined ? fromNanosNumber(nanos) : make4(exact);
     }
   }
   return invalid(input);
@@ -1992,7 +2103,7 @@ var DurationProto = {
     return pipeArguments(this, arguments);
   }
 };
-var make3 = (input) => {
+var make4 = (input) => {
   const duration = Object.create(DurationProto);
   if (typeof input === "number") {
     if (isNaN(input) || input === 0 || Object.is(input, -0)) {
@@ -2022,11 +2133,12 @@ var make3 = (input) => {
 };
 var isDuration = (u) => hasProperty(u, TypeId4);
 var isFinite = (self) => self.value._tag !== "Infinity" && self.value._tag !== "NegativeInfinity";
-var zero = /* @__PURE__ */ make3(0);
-var infinity = /* @__PURE__ */ make3(Infinity);
-var negativeInfinity = /* @__PURE__ */ make3(-Infinity);
-var nanos = (nanos) => make3(nanos);
-var millis = (millis) => make3(millis);
+var zero = /* @__PURE__ */ make4(0);
+var infinity = /* @__PURE__ */ make4(Infinity);
+var negativeInfinity = /* @__PURE__ */ make4(-Infinity);
+var nanos = (nanos) => make4(nanos);
+var millis = (millis) => make4(millis);
+var seconds = (seconds) => make4(seconds * 1000);
 var toMillis = (self) => match4(fromInputUnsafe(self), {
   onMillis: identity,
   onNanos: (nanos) => nanosToUnit(nanos, 1e6),
@@ -2267,7 +2379,7 @@ class ParentSpan extends (/* @__PURE__ */ Service()(ParentSpanKey, {
   fiberCached: true
 })) {
 }
-var make4 = (options) => options;
+var make5 = (options) => options;
 var DisablePropagation = /* @__PURE__ */ Reference("effect/Tracer/DisablePropagation", {
   defaultValue: constFalse
 });
@@ -2278,7 +2390,7 @@ var MinimumTraceLevel = /* @__PURE__ */ Reference("effect/Tracer/MinimumTraceLev
   defaultValue: () => "All"
 });
 var TracerKey = "effect/Tracer";
-var nativeTracer = /* @__PURE__ */ make4({
+var nativeTracer = /* @__PURE__ */ make5({
   span: (options) => new NativeSpan(options)
 });
 
@@ -2388,6 +2500,27 @@ var CurrentLogSpans = /* @__PURE__ */ Reference("effect/References/CurrentLogSpa
 });
 
 // node_modules/effect/dist/internal/tracer.js
+var addSpanStackTrace = (options) => {
+  if (options?.captureStackTrace === false) {
+    return options;
+  } else if (options?.captureStackTrace !== undefined && typeof options.captureStackTrace !== "boolean") {
+    return options;
+  }
+  const limit = getStackTraceLimit();
+  if (limit === 0 && options?.captureStackTrace !== true) {
+    return {
+      ...options,
+      captureStackTrace: false
+    };
+  }
+  setStackTraceLimit(3);
+  const traceError = new Error;
+  setStackTraceLimit(limit);
+  return {
+    ...options,
+    captureStackTrace: spanCleaner(() => traceError.stack)
+  };
+};
 var makeStackCleaner = (line) => (stack) => {
   let cache;
   return () => {
@@ -2404,6 +2537,7 @@ var makeStackCleaner = (line) => (stack) => {
     }
   };
 };
+var spanCleaner = /* @__PURE__ */ makeStackCleaner(3);
 
 // node_modules/effect/dist/internal/effect.js
 class Interrupt extends ReasonBase {
@@ -2442,6 +2576,19 @@ var hasDies = (self) => self.reasons.some(isDieReason);
 var causeElectDefects = (self) => hasDies(self) && hasFails(self) ? causeFromReasons(self.reasons.map((reason) => reason._tag === "Fail" && !isDone(reason.error) ? new Die(reason.error, reason.annotations) : reason)) : self;
 var findRecoverableError = (self) => hasDies(self) ? fail2(causeElectDefects(self)) : findError(self);
 var hasInterrupts = (self) => self.reasons.some(isInterruptReason);
+var causeFilterInterruptors = (self) => {
+  let interruptors;
+  for (let i = 0;i < self.reasons.length; i++) {
+    const f = self.reasons[i];
+    if (f._tag !== "Interrupt")
+      continue;
+    interruptors ??= new Set;
+    if (f.fiberId !== undefined) {
+      interruptors.add(f.fiberId);
+    }
+  }
+  return interruptors ? succeed2(interruptors) : fail2(self);
+};
 var hasInterruptsOnly = (self) => self.reasons.length > 0 && self.reasons.every(isInterruptReason);
 var reasonAnnotations = (self) => makeUnsafe(self.annotations);
 var causeMap = /* @__PURE__ */ dual(2, (self, f) => {
@@ -2590,9 +2737,9 @@ var currentStackTrace = (frame) => {
     if (stack) {
       const locationMatchAll = stack.matchAll(locationRegExp);
       let match = false;
-      for (const [, location] of locationMatchAll) {
+      for (const [, location2] of locationMatchAll) {
         match = true;
-        out.push(`    at ${current.name} (${location})`);
+        out.push(`    at ${current.name} (${location2})`);
       }
       if (!match) {
         out.push(`    at ${current.name} (${stack.replace(/^at /, "")})`);
@@ -2697,7 +2844,7 @@ class FiberImpl {
     }
     let cause = causeInterrupt(fiberId);
     if (this.cache.stackFrame) {
-      cause = causeAnnotate(cause, make2(StackTraceKey, this.cache.stackFrame));
+      cause = causeAnnotate(cause, make3(StackTraceKey, this.cache.stackFrame));
     }
     if (annotations) {
       cause = causeAnnotate(cause, annotations);
@@ -3009,7 +3156,7 @@ var failCauseSync = (evaluate) => suspend(() => failCause(evaluate()));
 var die = (defect) => exitDie(defect);
 var failSync = (error) => suspend(() => fail3(error()));
 var void_ = /* @__PURE__ */ succeed3(undefined);
-var try_ = (options) => {
+var try_2 = (options) => {
   const evaluate = typeof options === "function" ? options : options.try;
   const catcher = typeof options === "function" ? (cause) => new UnknownError(cause, "An error occurred in Effect.try") : options.catch;
   return suspend(() => {
@@ -3020,6 +3167,9 @@ var try_ = (options) => {
     }
   });
 };
+var promise = (evaluate) => callbackOptions(function(resume, signal) {
+  evaluate(signal).then((a) => resume(succeed3(a)), (e) => resume(die(e)));
+}, evaluate.length !== 0);
 var tryPromise = (options) => {
   const f = typeof options === "function" ? options : options.try;
   const catcher = typeof options === "function" ? (cause) => new UnknownError(cause, "An error occurred in Effect.tryPromise") : options.catch;
@@ -3337,8 +3487,9 @@ var flatMapEager = /* @__PURE__ */ dual(2, (self, f) => {
   }
   return flatMap2(self, f);
 });
-var map3 = /* @__PURE__ */ dual(2, (self, f) => new ContImpl(self, mapCont, f));
-var mapEager = /* @__PURE__ */ dual(2, (self, f) => effectIsExit(self) ? exitMap(self, f) : map3(self, f));
+var flatten2 = (self) => flatMap2(self, identity);
+var map4 = /* @__PURE__ */ dual(2, (self, f) => new ContImpl(self, mapCont, f));
+var mapEager = /* @__PURE__ */ dual(2, (self, f) => effectIsExit(self) ? exitMap(self, f) : map4(self, f));
 var mapErrorEager = /* @__PURE__ */ dual(2, (self, f) => effectIsExit(self) ? exitMapError(self, f) : mapError(self, f));
 var catchEager = /* @__PURE__ */ dual(2, (self, f) => {
   if (effectIsExit(self)) {
@@ -3408,9 +3559,9 @@ var provideService = function() {
   return dual(3, (self, service, impl) => provideServiceImpl(self, service, impl)).apply(this, arguments);
 };
 var provideServiceImpl = (self, service, implementation) => updateContext(self, add(service, implementation));
-var zipWith = /* @__PURE__ */ dual((args) => isEffect(args[1]), (self, that, f, options) => options?.concurrent ? map3(all([self, that], {
+var zipWith = /* @__PURE__ */ dual((args) => isEffect(args[1]), (self, that, f, options) => options?.concurrent ? map4(all([self, that], {
   concurrency: 2
-}), ([a, a2]) => f(a, a2)) : flatMap2(self, (a) => map3(that, (a2) => f(a, a2))));
+}), ([a, a2]) => f(a, a2)) : flatMap2(self, (a) => map4(that, (a2) => f(a, a2))));
 var forever = /* @__PURE__ */ dual((args) => isEffect(args[0]), (self, options) => whileLoop({
   while: constTrue,
   body: constant(options?.disableYield ? self : flatMap2(self, (_) => yieldNow)),
@@ -3773,6 +3924,14 @@ var onExitFilter = /* @__PURE__ */ dual(3, (self, filter, f) => onExit(self, (ex
   return isFailure2(b) ? void_ : f(b.success, exit);
 }));
 var onError = /* @__PURE__ */ dual(2, (self, f) => onExitFilter(self, exitFilterCause, f));
+var onErrorFilter = /* @__PURE__ */ dual(3, (self, filter, f) => onExit(self, (exit) => {
+  if (exit._tag !== "Failure") {
+    return void_;
+  }
+  const result = filter(exit.cause);
+  return isFailure2(result) ? void_ : f(result.success, exit.cause);
+}));
+var onInterrupt = /* @__PURE__ */ dual(2, (self, finalizer) => onErrorFilter(causeFilterInterruptors, finalizer)(self));
 var infiniteTTL = /* @__PURE__ */ constant(Infinity);
 var makeCachedUnsafe = (self, ttlMillis) => {
   let expiresAt = 0;
@@ -3873,7 +4032,7 @@ var all = (arg, options) => {
   } else if (options?.discard) {
     return options.mode === "result" ? forEach(Object.values(arg), result, options) : forEach(Object.values(arg), identity, options);
   }
-  return suspend(() => map3(forEach(Object.entries(arg), ([key, effect]) => map3(options?.mode === "result" ? result(effect) : effect, (value) => [key, value]), {
+  return suspend(() => map4(forEach(Object.entries(arg), ([key, effect]) => map4(options?.mode === "result" ? result(effect) : effect, (value) => [key, value]), {
     concurrency: options?.concurrency
   }), Object.fromEntries));
 };
@@ -4144,6 +4303,25 @@ var fiberRunIn = /* @__PURE__ */ dual(2, (self, scope) => {
   return self;
 });
 var runFork = /* @__PURE__ */ runForkWith(/* @__PURE__ */ empty());
+var runPromiseExitWith = (context) => {
+  const runFork = runForkWith(context);
+  return (effect, options) => {
+    const fiber = runFork(effect, options);
+    return new Promise((resolve) => {
+      fiber.addObserver((exit) => resolve(exit));
+    });
+  };
+};
+var runPromiseWith = (context) => {
+  const runPromiseExit = runPromiseExitWith(context);
+  return (effect, options) => runPromiseExit(effect, options).then((exit) => {
+    if (exit._tag === "Failure") {
+      throw causeSquash(exit.cause);
+    }
+    return exit.value;
+  });
+};
+var runPromise = /* @__PURE__ */ runPromiseWith(/* @__PURE__ */ empty());
 var runSyncExitWith = (context) => {
   const runFork = runForkWith(context);
   return (effect) => {
@@ -4158,6 +4336,16 @@ var runSyncExitWith = (context) => {
   };
 };
 var runSyncExit = /* @__PURE__ */ runSyncExitWith(/* @__PURE__ */ empty());
+var runSyncWith = (context) => {
+  const runSyncExit = runSyncExitWith(context);
+  return (effect) => {
+    const exit = runSyncExit(effect);
+    if (exit._tag === "Failure")
+      throw causeSquash(exit.cause);
+    return exit.value;
+  };
+};
+var runSync = /* @__PURE__ */ runSyncWith(/* @__PURE__ */ empty());
 var succeedTrue = /* @__PURE__ */ succeed3(true);
 var succeedFalse = /* @__PURE__ */ succeed3(false);
 
@@ -4309,6 +4497,14 @@ var makeSpanUnsafe = (fiber, name, options) => {
   }
   return span;
 };
+var provideSpanStackFrame = (name, stack) => {
+  stack = typeof stack === "function" ? stack : constUndefined;
+  return updateService(CurrentStackFrame, (parent) => ({
+    name,
+    stack,
+    parent
+  }));
+};
 var endSpan = (span, exit, clock, timingEnabled) => sync(() => {
   if (span.status._tag === "Ended")
     return;
@@ -4326,6 +4522,20 @@ var useSpan = (name, ...args) => {
   });
 };
 var provideParentSpan = /* @__PURE__ */ provideService(ParentSpan);
+var withParentSpan = function() {
+  const dataFirst = isEffect(arguments[0]);
+  const span = dataFirst ? arguments[1] : arguments[0];
+  let options = dataFirst ? arguments[2] : arguments[1];
+  let provideStackFrame = identity;
+  if (span._tag === "Span") {
+    options = addSpanStackTrace(options);
+    provideStackFrame = provideSpanStackFrame(span.name, options?.captureStackTrace);
+  }
+  if (dataFirst) {
+    return provideParentSpan(provideStackFrame(arguments[0]), span);
+  }
+  return (self) => provideParentSpan(provideStackFrame(self), span);
+};
 var ClockRef = /* @__PURE__ */ Reference("effect/Clock", {
   defaultValue: () => new ClockImpl
 });
@@ -4591,8 +4801,9 @@ var die2 = causeDie;
 var makeFailReason = (error) => new Fail(error);
 var makeDieReason = (defect) => new Die(defect);
 var hasInterruptsOnly2 = hasInterruptsOnly;
-var map4 = causeMap;
+var map5 = causeMap;
 var squash = causeSquash;
+var hasInterrupts2 = hasInterrupts;
 var isDone2 = isDone;
 var Done2 = Done;
 var done2 = done;
@@ -4659,6 +4870,7 @@ var doneUnsafe = (self, effect) => {
 
 // node_modules/effect/dist/References.js
 var MinimumLogLevel2 = MinimumLogLevel;
+var TracerTimingEnabled2 = TracerTimingEnabled;
 
 // node_modules/effect/dist/Scope.js
 var Scope = scopeTag;
@@ -4762,13 +4974,13 @@ class CurrentMemoMap extends (/* @__PURE__ */ Service()("effect/Layer/CurrentMem
     return current ? forkMemoMapUnsafe(current) : makeMemoMapUnsafe();
   }
 }
-var buildWithMemoMap = /* @__PURE__ */ dual(3, (self, memoMap, scope) => provideService(map3(suspend(() => self.build(memoMap, scope)), add(CurrentMemoMap, memoMap)), CurrentMemoMap, memoMap));
+var buildWithMemoMap = /* @__PURE__ */ dual(3, (self, memoMap, scope) => provideService(map4(suspend(() => self.build(memoMap, scope)), add(CurrentMemoMap, memoMap)), CurrentMemoMap, memoMap));
 var buildWithScope = /* @__PURE__ */ dual(2, (self, scope) => withFiber((fiber) => buildWithMemoMap(self, CurrentMemoMap.forkOrCreate(fiber.context), scope)));
 var succeed5 = function() {
   if (arguments.length === 1) {
-    return (resource) => succeedContext(make2(arguments[0], resource));
+    return (resource) => succeedContext(make3(arguments[0], resource));
   }
-  return succeedContext(make2(arguments[0], arguments[1]));
+  return succeedContext(make3(arguments[0], arguments[1]));
 };
 var succeedContext = (context) => fromBuildUnsafe(constant(succeed3(context)));
 var effect = function() {
@@ -4777,18 +4989,21 @@ var effect = function() {
   }
   return effectImpl(arguments[0], arguments[1]);
 };
-var effectImpl = (service, effect) => effectContext(map3(effect, (value) => make2(service, value)));
+var effectImpl = (service, effect) => effectContext(map4(effect, (value) => make3(service, value)));
 var effectContext = (effect) => fromBuildMemo((_, scope) => provide(effect, scope));
 var mergeAllEffect = (layers, memoMap, scope) => {
   const parentScope = forkUnsafe2(scope, "parallel");
   return forEach(layers, (layer) => layer.build(memoMap, forkUnsafe2(parentScope, "sequential")), {
     concurrency: layers.length
-  }).pipe(map3((context) => mergeAll(...context)));
+  }).pipe(map4((context) => mergeAll(...context)));
 };
 var mergeAll2 = (...layers) => fromBuildMemo((memoMap, scope) => mergeAllEffect(layers, memoMap, scope));
-var provideWith = (self, that, f) => fromBuildMemo((memoMap, scope) => flatMap2(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), (context) => self.build(memoMap, scope).pipe(provideContext(context), map3((merged) => f(merged, context)))));
+var provideWith = (self, that, f) => fromBuildMemo((memoMap, scope) => flatMap2(Array.isArray(that) ? mergeAllEffect(that, memoMap, scope) : that.build(memoMap, scope), (context) => self.build(memoMap, scope).pipe(provideContext(context), map4((merged) => f(merged, context)))));
 var provideMerge = /* @__PURE__ */ dual(2, (self, that) => provideWith(self, that, (self, that) => merge(that, self)));
 
+// node_modules/effect/dist/Clock.js
+var Clock = ClockRef;
+
 // node_modules/effect/dist/Number.js
 var Number3 = globalThis.Number;
 var round = /* @__PURE__ */ dual(2, (self, precision) => {
@@ -4839,6 +5054,7 @@ var isEffect2 = isEffect;
 var all2 = all;
 var forEach2 = forEach;
 var whileLoop2 = whileLoop;
+var promise2 = promise;
 var tryPromise2 = tryPromise;
 var succeed6 = succeed3;
 var suspend2 = suspend;
@@ -4852,14 +5068,15 @@ var failSync2 = failSync;
 var failCause3 = failCause;
 var failCauseSync2 = failCauseSync;
 var die3 = die;
-var try_2 = try_;
+var try_3 = try_2;
 var withFiber2 = withFiber;
 var fromResult2 = fromResult;
 var flatMap3 = flatMap2;
+var flatten3 = flatten2;
 var andThen2 = andThen;
 var tap2 = tap;
 var exit2 = exit;
-var map5 = map3;
+var map6 = map4;
 var as2 = as;
 var asVoid2 = asVoid;
 var zipWith2 = zipWith;
@@ -4886,6 +5103,7 @@ var contextWith2 = contextWith;
 var provide3 = provide2;
 var provideContext2 = provideContext;
 var serviceOption2 = serviceOption;
+var updateContext2 = updateContext;
 var provideService2 = provideService;
 var scope2 = scope;
 var scoped2 = scoped;
@@ -4898,14 +5116,19 @@ var onExitPrimitive2 = onExitPrimitive;
 var onExit2 = onExit;
 var cached2 = cached;
 var interrupt2 = interrupt;
+var onInterrupt2 = onInterrupt;
 var uninterruptible2 = uninterruptible;
 var uninterruptibleMask2 = uninterruptibleMask;
 var forever2 = forever;
+var useSpan2 = useSpan;
+var withParentSpan2 = withParentSpan;
 var forkChild2 = forkChild;
 var forkIn2 = forkIn;
 var forkScoped2 = forkScoped;
 var runFork2 = runFork;
 var runForkWith2 = runForkWith;
+var runPromise2 = runPromise;
+var runSync2 = runSync;
 var runSyncExit2 = runSyncExit;
 var fnUntraced2 = fnUntraced;
 var fn2 = fn;
@@ -5106,7 +5329,7 @@ var binaryUnits = [decimalUnits[0], {
 }];
 var allUnits = [...decimalUnits, .../* @__PURE__ */ binaryUnits.slice(1)];
 var unitsByName = /* @__PURE__ */ new Map(/* @__PURE__ */ allUnits.flatMap((unit) => unit.names.map((name) => [name, unit])));
-var make5 = (value) => value;
+var make6 = (value) => value;
 var invalid2 = (message) => {
   throw new Error(`Invalid ByteSize: ${message}`);
 };
@@ -5114,7 +5337,7 @@ var fromNumber = (input) => {
   if (!Number.isSafeInteger(input) || input < 0) {
     return invalid2(`expected a non-negative safe integer, received ${input}`);
   }
-  return make5(BigInt(input));
+  return make6(BigInt(input));
 };
 var fromStringUnsafe = (input) => {
   const match = /^\s*(\d+)(?:\.(\d+))?\s*([A-Za-z]+)\s*$/.exec(input);
@@ -5129,14 +5352,14 @@ var fromStringUnsafe = (input) => {
   if (numerator % scale !== bigint03) {
     return invalid2(`${JSON.stringify(input)} does not represent an integral number of bytes`);
   }
-  return make5(numerator / scale);
+  return make6(numerator / scale);
 };
 var fromInputUnsafe2 = (input) => {
   switch (typeof input) {
     case "bigint":
       if (input < bigint03)
         return invalid2(`expected a non-negative bigint, received ${input}`);
-      return make5(input);
+      return make6(input);
     case "number":
       return fromNumber(input);
     case "string":
@@ -5698,7 +5921,7 @@ var isIgnorable = (error) => isMissing(error) || error.reason._tag === "Permissi
 var isNotLink = (error) => isIgnorable(error) || error.reason._tag === "Unknown";
 var DIRECTORY_CONCURRENCY = 16;
 var byName = /* @__PURE__ */ mapInput(String2, (entry) => entry.name);
-var make6 = (fs) => (pattern, options) => walk(fs, compile([pattern], options?.dot ?? false), options);
+var make7 = (fs) => (pattern, options) => walk(fs, compile([pattern], options?.dot ?? false), options);
 var walk = /* @__PURE__ */ fnUntraced2(function* (fs, compiled, options) {
   if (compiled.initial.size === 0) {
     return [];
@@ -5710,7 +5933,7 @@ var walk = /* @__PURE__ */ fnUntraced2(function* (fs, compiled, options) {
   const isUnlisted = (value) => value === "." || value === ".." || isRoot(value);
   const probe = (parent, name, named) => {
     const path = toFsPath(join3(parent, name));
-    return fs.stat(path).pipe(map5((info) => info.type), catchReason2("PlatformError", "NotFound", () => fs.readLink(path).pipe(as2("SymbolicLink"), catchIf2(isNotLink, () => succeed6(undefined)))), catchIf2(named ? isMissing : isIgnorable, () => succeed6(undefined)), map5((type) => type === undefined ? undefined : {
+    return fs.stat(path).pipe(map6((info) => info.type), catchReason2("PlatformError", "NotFound", () => fs.readLink(path).pipe(as2("SymbolicLink"), catchIf2(isNotLink, () => succeed6(undefined)))), catchIf2(named ? isMissing : isIgnorable, () => succeed6(undefined)), map6((type) => type === undefined ? undefined : {
       name,
       type
     }));
@@ -5765,7 +5988,7 @@ var walk = /* @__PURE__ */ fnUntraced2(function* (fs, compiled, options) {
       return child(type === "Directory", false);
     }
     const path = toFsPath(relative);
-    return fs.stat(path).pipe(map5((info) => info.type === "Directory"), catchIf2(isIgnorable, () => succeed6(false)), flatMap3((isDirectory) => {
+    return fs.stat(path).pipe(map6((info) => info.type === "Directory"), catchIf2(isIgnorable, () => succeed6(false)), flatMap3((isDirectory) => {
       const resolved = child(isDirectory, type === "SymbolicLink");
       if (type === "SymbolicLink" || resolved?.next === undefined || result.globstar.size === 0) {
         return succeed6(resolved);
@@ -5791,7 +6014,7 @@ var walk = /* @__PURE__ */ fnUntraced2(function* (fs, compiled, options) {
       const child = visit(entry, relative, states, excluded);
       if (isEffect2(child)) {
         const index = children.push(undefined) - 1;
-        pending.push(map5(child, (child) => {
+        pending.push(map6(child, (child) => {
           children[index] = child;
         }));
       } else {
@@ -5895,7 +6118,7 @@ var MutableRefProto = {
     };
   }
 };
-var make7 = (value) => {
+var make8 = (value) => {
   const ref = Object.create(MutableRefProto);
   ref.current = value;
   return ref;
@@ -5903,7 +6126,7 @@ var make7 = (value) => {
 
 // node_modules/effect/dist/MutableList.js
 var Empty = /* @__PURE__ */ Symbol.for("effect/MutableList/Empty");
-var make8 = () => ({
+var make9 = () => ({
   head: undefined,
   tail: undefined,
   length: 0
@@ -6014,12 +6237,12 @@ var QueueProto = {
     };
   }
 };
-var make9 = (options) => withFiber((fiber) => {
+var make10 = (options) => withFiber((fiber) => {
   const self = Object.create(QueueProto);
   self.dispatcher = fiber.currentDispatcher;
   self.capacity = options?.capacity ?? Number.POSITIVE_INFINITY;
   self.strategy = options?.strategy ?? "suspend";
-  self.messages = make8();
+  self.messages = make9();
   self.scheduleRunning = false;
   self.state = {
     _tag: "Open",
@@ -6029,10 +6252,10 @@ var make9 = (options) => withFiber((fiber) => {
   };
   return succeed3(self);
 });
-var bounded = (capacity) => make9({
+var bounded = (capacity) => make10({
   capacity
 });
-var sliding = (capacity) => make9({
+var sliding = (capacity) => make10({
   capacity,
   strategy: "sliding"
 });
@@ -6302,13 +6525,13 @@ var fromTransformBracket = (f) => fromTransform(fnUntraced2(function* (upstream,
   return onError2(pull, onCause);
 }));
 var toTransform = (channel) => channel.transform;
-var asyncQueue = (scope, f, options) => make9({
+var asyncQueue = (scope, f, options) => make10({
   capacity: options?.bufferSize,
   strategy: options?.strategy
 }).pipe(tap2((queue) => addFinalizer2(scope, shutdown(queue))), tap2((queue) => provide(f(queue), scope).pipe(catchCause2((cause) => failCause4(queue, cause)), forkIn2(scope, {
   startImmediately: true
 }))));
-var callbackArray = (f, options) => fromTransform((_, scope) => map5(asyncQueue(scope, f, options), takeAll2));
+var callbackArray = (f, options) => fromTransform((_, scope) => map6(asyncQueue(scope, f, options), takeAll2));
 var suspend3 = (evaluate) => fromTransform((upstream, scope) => suspend2(() => toTransform(evaluate())(upstream, scope)));
 var succeed7 = (value) => fromEffect(succeed6(value));
 var empty3 = /* @__PURE__ */ fromPull(/* @__PURE__ */ succeed6(/* @__PURE__ */ done2()));
@@ -6323,6 +6546,35 @@ var fromEffect = (effect) => fromPull(sync2(() => {
   });
 }));
 var fromEffectDrain = (effect) => fromPull(flatMap3(effect, () => done2()));
+var fromReadableStream = (options) => fromTransform((_, scope) => readableStreamToPullUnsafe({
+  scope,
+  readable: options.evaluate(),
+  onError: options.onError,
+  releaseLockOnEnd: options.releaseLockOnEnd
+}));
+var readableStreamToPullUnsafe = (options) => {
+  const reader = options.readable.getReader();
+  const exit = options.exit ?? make8(undefined);
+  const pull = suspend2(() => {
+    if (exit.current)
+      return exit.current;
+    return matchCauseEffect2(tryPromise2({
+      try: () => reader.read(),
+      catch: options.onError
+    }), {
+      onFailure: (cause) => exit.current ?? failCause3(cause),
+      onSuccess: ({
+        done,
+        value
+      }) => {
+        if (exit.current)
+          return exit.current;
+        return done ? done2() : succeed6(of(value));
+      }
+    });
+  });
+  return as2(addFinalizer2(options.scope, options.releaseLockOnEnd ? sync2(() => reader.releaseLock()) : promise2(() => reader.cancel().catch((error) => reader.closed.then(() => Promise.reject(error), constVoid))).pipe(ensuring2(sync2(() => reader.releaseLock())))), pull);
+};
 var mapDone = /* @__PURE__ */ dual(2, (self, f) => mapDoneEffect(self, (o) => succeed6(f(o))));
 var mapDoneEffect = /* @__PURE__ */ dual(2, (self, f) => transformPull(self, (pull) => succeed6(catchDone(pull, (done) => flatMap3(f(done), done2)))));
 var tapError3 = /* @__PURE__ */ dual(2, (self, f) => transformPull(self, (pull) => succeed6(tapError2(pull, (err) => isDone2(err) ? void_3 : asVoid2(f(err))))));
@@ -6444,7 +6696,7 @@ var decodeText = (encoding, options) => fromTransform((upstream, _scope) => sync
   const streamOptions = {
     stream: true
   };
-  let pull = upstream.pipe(map5(map2((bytes) => decoder.decode(bytes, streamOptions))), catchDone((leftover) => {
+  let pull = upstream.pipe(map6(map3((bytes) => decoder.decode(bytes, streamOptions))), catchDone((leftover) => {
     pull = done2(leftover);
     const last = decoder.decode();
     return last.length > 0 ? succeed6(of(last)) : pull;
@@ -6465,6 +6717,11 @@ var unwrap = (channel) => fromTransform((upstream, scope) => {
     return channel.pipe(provide(scope), flatMap3((channel) => toTransform(channel)(upstream, scope)), flatMap3((pull_) => pull = pull_));
   }));
 });
+var interruptWhen = /* @__PURE__ */ dual(2, (self, effect) => merge2(self, fromPull(succeed6(flatMap3(effect, done2))), {
+  haltStrategy: "either"
+}));
+var onExit3 = /* @__PURE__ */ dual(2, (self, finalizer) => fromTransformBracket((upstream, scope, forkedScope) => addFinalizerExit(forkedScope, finalizer).pipe(andThen2(toTransform(self)(upstream, scope)))));
+var ensuring3 = /* @__PURE__ */ dual(2, (self, finalizer) => onExit3(self, (_) => finalizer));
 var runWith = (self, f, onHalt) => suspend2(() => {
   const scope = makeUnsafe3();
   const makePull = toTransform(self)(done2(), scope);
@@ -6473,6 +6730,31 @@ var runWith = (self, f, onHalt) => suspend2(() => {
 var runDrain = (self) => runWith(self, (pull) => forever2(pull, {
   disableYield: true
 }));
+var runForEach = /* @__PURE__ */ dual(2, (self, f) => runWith(self, (pull) => forever2(flatMap3(pull, f), {
+  disableYield: true
+})));
+var mkUint8Array = (self) => map6(runFold(self, () => ({
+  bytes: 0,
+  arrays: []
+}), (acc, chunk) => {
+  for (let i = 0;i < chunk.length; i++) {
+    acc.bytes += chunk[i].length;
+    acc.arrays.push(chunk[i]);
+  }
+  return acc;
+}), ({
+  arrays,
+  bytes
+}) => {
+  const result = new Uint8Array(bytes);
+  let offset = 0;
+  for (let i = 0;i < arrays.length; i++) {
+    const array = arrays[i];
+    result.set(array, offset);
+    offset += array.length;
+  }
+  return result;
+});
 var runFold = /* @__PURE__ */ dual(3, (self, initial, f) => suspend2(() => {
   let state = initial();
   return runWith(self, (pull) => whileLoop2({
@@ -6538,7 +6820,7 @@ var forEach3 = (f) => forEachArray(forEach2((_) => f(_), {
 var forEachArray = (f) => fromTransform2((upstream) => upstream.pipe(flatMap3(f), forever2({
   disableYield: true
 }), catchDone(() => endVoid)));
-var unwrap2 = (effect) => fromChannel2(unwrap(map5(effect, toChannel)));
+var unwrap2 = (effect) => fromChannel2(unwrap(map6(effect, toChannel)));
 
 // node_modules/effect/dist/internal/rcRef.js
 var TypeId13 = "~effect/RcRef";
@@ -6570,7 +6852,7 @@ class RcRefImpl {
     this.idleTimeToLive = idleTimeToLive;
   }
 }
-var make10 = (options) => withFiber2((fiber) => {
+var make11 = (options) => withFiber2((fiber) => {
   const context = fiber.context;
   const scope = get(context, Scope);
   const ref = new RcRefImpl(options.acquire, context, scope, options.idleTimeToLive !== undefined ? fromInputUnsafe(options.idleTimeToLive) : undefined);
@@ -6679,7 +6961,7 @@ var release = (self, state) => {
 };
 
 // node_modules/effect/dist/RcRef.js
-var make11 = make10;
+var make12 = make11;
 var get3 = get2;
 
 // node_modules/effect/dist/Stream.js
@@ -6691,7 +6973,7 @@ var transformPull2 = (self, f) => fromChannel3(fromTransform((_, scope) => flatM
 var toChannel2 = (stream) => stream.channel;
 var callback3 = (f, options) => fromChannel3(callbackArray(f, options));
 var empty4 = /* @__PURE__ */ fromChannel3(empty3);
-var make12 = (...values) => fromArray2(values);
+var make13 = (...values) => fromArray2(values);
 var suspend4 = (stream) => {
   const suspended = fromChannel3(suspend3(() => stream().channel));
   suspendedStreams.set(suspended, stream);
@@ -6700,7 +6982,8 @@ var suspend4 = (stream) => {
 var suspendedStreams = /* @__PURE__ */ new WeakMap;
 var fail9 = (error) => fromChannel3(fail8(error));
 var fromArray2 = (array) => isReadonlyArrayNonEmpty(array) ? fromChannel3(succeed7(array)) : empty4;
-var unwrap3 = (effect) => fromChannel3(unwrap(map5(effect, toChannel2)));
+var fromReadableStream2 = (options) => fromChannel3(fromReadableStream(options));
+var unwrap3 = (effect) => fromChannel3(unwrap(map6(effect, toChannel2)));
 var drainFork = /* @__PURE__ */ dual(2, (self, that) => mergeEffect2(self, runDrain2(that)));
 var merge3 = /* @__PURE__ */ dual((args) => isStream(args[0]) && isStream(args[1]), (self, that, options) => fromChannel3(merge2(toChannel2(self), toChannel2(that), options)));
 var mergeEffect2 = /* @__PURE__ */ dual(2, (self, effect) => self.channel.pipe(mergeEffect(effect), fromChannel3));
@@ -6719,7 +7002,7 @@ var transduce = /* @__PURE__ */ dual(2, (self, sink) => transformPull2(self, (up
     done = fail5(error);
     return done2();
   }));
-  const pull = map5(suspend2(() => sink.transform(upstreamWithLeftover, scope)), ([value, leftover_]) => {
+  const pull = map6(suspend2(() => sink.transform(upstreamWithLeftover, scope)), ([value, leftover_]) => {
     leftover = leftover_;
     return of(value);
   });
@@ -6727,7 +7010,9 @@ var transduce = /* @__PURE__ */ dual(2, (self, sink) => transformPull2(self, (up
 })));
 var decodeText2 = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, options) => self.channel.pipe(pipeTo(decodeText(options?.encoding)), fromChannel3));
 var splitLines2 = (self) => self.channel.pipe(pipeTo(splitLines()), fromChannel3);
-var run = /* @__PURE__ */ dual(2, (self, sink) => scopedWith2((scope) => toPullScoped(self.channel, scope).pipe(flatMap3((upstream) => runSink(sink, upstream, scope)), map5(([a]) => a))));
+var interruptWhen2 = /* @__PURE__ */ dual(2, (self, effect) => fromChannel3(interruptWhen(self.channel, effect)));
+var ensuring4 = /* @__PURE__ */ dual(2, (self, finalizer) => fromChannel3(ensuring3(self.channel, finalizer)));
+var run = /* @__PURE__ */ dual(2, (self, sink) => scopedWith2((scope) => toPullScoped(self.channel, scope).pipe(flatMap3((upstream) => runSink(sink, upstream, scope)), map6(([a]) => a))));
 var runSink = (sink, upstream, scope) => restoreUpstreamFailure(sink.transform(upstreamFailureToDefect(upstream), scope));
 var runCollect = (self) => runFold(self.channel, () => [], (acc, chunk) => {
   for (let i = 0;i < chunk.length; i++) {
@@ -6737,16 +7022,68 @@ var runCollect = (self) => runFold(self.channel, () => [], (acc, chunk) => {
 });
 var runDrain2 = (self) => runDrain(self.channel);
 var mkString = (self) => runFold(self.channel, () => "", (acc, chunk) => acc + chunk.join(""));
+var mkArrayBuffer = (self) => map6(mkUint8Array(self.channel), (bytes) => bytes.buffer);
+var toReadableStreamWith = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, context, options) => {
+  let currentResolve = undefined;
+  let fiber = undefined;
+  let cancelled = false;
+  const latch = makeUnsafe4(false);
+  const signal = options?.signal;
+  const onAbort = () => fiber.interruptUnsafe();
+  return new ReadableStream({
+    start(controller) {
+      fiber = runFork2(provideContext2(runForEach(transformPull(self.channel, (pull) => succeed6(latch.whenOpen(pull))), (chunk) => sync2(() => {
+        latch.closeUnsafe();
+        for (let i = 0;i < chunk.length; i++) {
+          controller.enqueue(chunk[i]);
+        }
+        currentResolve();
+        currentResolve = undefined;
+      })), context));
+      fiber.addObserver((exit) => {
+        signal?.removeEventListener("abort", onAbort);
+        if (cancelled)
+          return;
+        if (exit._tag === "Failure" && signal?.aborted !== true) {
+          controller.error(squash(exit.cause));
+        } else {
+          controller.close();
+        }
+      });
+      if (signal !== undefined && fiber.pollUnsafe() === undefined) {
+        if (signal.aborted)
+          onAbort();
+        else
+          signal.addEventListener("abort", onAbort, {
+            once: true
+          });
+      }
+    },
+    pull() {
+      return new Promise((resolve) => {
+        currentResolve = resolve;
+        latch.openUnsafe();
+      });
+    },
+    cancel() {
+      if (!fiber)
+        return;
+      cancelled = true;
+      return runPromise2(asVoid2(interrupt3(fiber)));
+    }
+  }, options?.strategy);
+});
+var toReadableStreamEffect = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, options) => map6(context2(), (context) => toReadableStreamWith(self, context, options)));
 
 // node_modules/effect/dist/FileSystem.js
 var TypeId15 = "~effect/FileSystem";
 var FileSystem = /* @__PURE__ */ Service("effect/FileSystem");
-var make13 = (impl) => FileSystem.of({
+var make14 = (impl) => FileSystem.of({
   ...impl,
   [TypeId15]: TypeId15,
-  glob: make6(impl),
+  glob: make7(impl),
   exists: (path) => pipe(impl.access(path), as2(true), catchTag2("PlatformError", (e) => e.reason._tag === "NotFound" ? succeed6(false) : fail7(e))),
-  readFileString: (path, encoding) => flatMap3(impl.readFile(path), (_) => try_2({
+  readFileString: (path, encoding) => flatMap3(impl.readFile(path), (_) => try_3({
     try: () => new TextDecoder(encoding).decode(_),
     catch: (cause) => badArgument({
       module: "FileSystem",
@@ -6783,8 +7120,8 @@ var make13 = (impl) => FileSystem.of({
   sink: (path, options) => pipe(impl.open(path, {
     ...options,
     flag: options?.flag ?? "w"
-  }), map5((file) => forEach3((_) => file.writeAll(_))), unwrap2),
-  writeFileString: (path, data, options) => flatMap3(try_2({
+  }), map6((file) => forEach3((_) => file.writeAll(_))), unwrap2),
+  writeFileString: (path, data, options) => flatMap3(try_3({
     try: () => new TextEncoder().encode(data),
     catch: (cause) => badArgument({
       module: "FileSystem",
@@ -6801,7 +7138,7 @@ class WatchBackend extends (/* @__PURE__ */ Service()("effect/FileSystem/WatchBa
 // node_modules/effect/dist/Path.js
 var TypeId16 = "~effect/Path";
 var Path = /* @__PURE__ */ Service("effect/Path");
-var make14 = (impl) => Path.of({
+var make15 = (impl) => Path.of({
   ...impl,
   [TypeId16]: TypeId16,
   resolveWithin(root, input) {
@@ -6973,7 +7310,7 @@ function normalizeFilterOutput(ast, out, input, options) {
     if (!isReadonlyArrayNonEmpty(out)) {
       return;
     }
-    return out.length === 1 ? makeFilterIssue(out[0], input, options) : new Composite(ast, map2(out, (entry) => makeFilterIssue(entry, input, options)), input, options);
+    return out.length === 1 ? makeFilterIssue(out[0], input, options) : new Composite(ast, map3(out, (entry) => makeFilterIssue(entry, input, options)), input, options);
   }
   return makeSingle(out, input, options);
 }
@@ -7737,7 +8074,7 @@ var wrapPropertyKeyIssue = (s, ast, key, exit) => {
   }
   const issue = getSchemaIssue(exit.cause);
   if (issue === undefined) {
-    return failCause2(map4(exit.cause, (issue) => new Composite(ast, [new Pointer([key], issue)], s.input, s.options)));
+    return failCause2(map5(exit.cause, (issue) => new Composite(ast, [new Pointer([key], issue)], s.input, s.options)));
   }
   const pointer = new Pointer([key], issue);
   if (s.options.errors === "all") {
@@ -9078,8 +9415,8 @@ var HandleProto = {
 var makeHandle = (params) => Object.setPrototypeOf({
   ...params
 }, HandleProto);
-var make15 = (spawn) => {
-  const streamString = (command, options) => spawn(command).pipe(map5((handle) => decodeText2(options?.includeStderr === true ? handle.all : drainFork(handle.stdout, handle.stderr))), unwrap3);
+var make16 = (spawn) => {
+  const streamString = (command, options) => spawn(command).pipe(map6((handle) => decodeText2(options?.includeStderr === true ? handle.all : drainFork(handle.stdout, handle.stderr))), unwrap3);
   const streamLines = (command, options) => splitLines2(streamString(command, options));
   return ChildProcessSpawner.of({
     spawn,
@@ -9107,7 +9444,7 @@ var value = (self) => {
 // node_modules/effect/dist/Redacted.js
 var TypeId20 = "~effect/Redacted";
 var isRedacted = (u) => hasProperty(u, TypeId20);
-var make16 = (value, options) => {
+var make17 = (value, options) => {
   const self = Object.create(Proto2);
   if (options?.label) {
     self.label = options.label;
@@ -9251,7 +9588,7 @@ var parseTemplate = (texts, values) => {
     if (word.length === 0)
       return;
     const value = word.map(unwrap4).join("");
-    words.push(word.length === 1 && isRedacted(word[0]) ? word[0] : word.some(isRedacted) ? make16(value) : value);
+    words.push(word.length === 1 && isRedacted(word[0]) ? word[0] : word.some(isRedacted) ? make17(value) : value);
     word = [];
     plain = true;
     braceDepth = 0;
@@ -9357,7 +9694,7 @@ var makeStandardCommand = (command, args, options) => Object.assign(Object.creat
   args,
   options
 });
-var make17 = function make(...args) {
+var make18 = function make(...args) {
   if (isTemplateString(args[0])) {
     const [templates, ...expressions] = args;
     const [command, cmdArgs] = parseTemplate2(templates, expressions);
@@ -9624,7 +9961,7 @@ var readableToPullUnsafe = (options) => {
   const readable = options.readable;
   const chunkSize = options.chunkSize ?? 4096;
   const closeOnDone = options.closeOnDone ?? true;
-  const exit = options.exit ?? make7(undefined);
+  const exit = options.exit ?? make8(undefined);
   const latch = options.latch ?? makeUnsafe4(false);
   function onReadable() {
     latch.openUnsafe();
@@ -9728,7 +10065,7 @@ var taskkill = (childProcess, onExit = () => {}) => {
     windowsHide: true
   }, onExit);
 };
-var make18 = /* @__PURE__ */ gen2(function* () {
+var make19 = /* @__PURE__ */ gen2(function* () {
   const fs = yield* FileSystem;
   const path = yield* Path;
   const resolveWorkingDirectory = fnUntraced2(function* (options) {
@@ -9855,7 +10192,7 @@ var make18 = /* @__PURE__ */ gen2(function* () {
         });
       }
       if (stream) {
-        return map5(runInputStream(stream, sink, inputFailure), () => {
+        return map6(runInputStream(stream, sink, inputFailure), () => {
           inputSinks.set(fd, sink);
         });
       }
@@ -9993,7 +10330,7 @@ var make18 = /* @__PURE__ */ gen2(function* () {
         });
       });
     }
-    return try_2({
+    return try_3({
       try: () => {
         globalThis.process.kill(-childProcess.pid, signal);
       },
@@ -10148,7 +10485,7 @@ var make18 = /* @__PURE__ */ gen2(function* () {
           getInputFd,
           getOutputFd
         } = yield* setupAdditionalFds(cmd, childProcess, resolvedAdditionalFds, inputFailure);
-        const isRunning = map5(isDone3(exitSignal), (done) => !done);
+        const isRunning = map6(isDone3(exitSignal), (done) => !done);
         const exitCode = flatMap3(raceFirst2(_await(exitSignal), _await(inputFailure)), ([code, signal]) => {
           if (isDoneUnsafe(inputFailure)) {
             return _await(inputFailure);
@@ -10188,7 +10525,7 @@ var make18 = /* @__PURE__ */ gen2(function* () {
           const sourceStream = unwrap3(succeed6(getSourceStream(handles[handles.length - 1], options.from)));
           const toOption = options.to ?? "stdin";
           if (toOption === "stdin") {
-            handles.push(yield* spawnCommand(make17(command.command, command.args, {
+            handles.push(yield* spawnCommand(make18(command.command, command.args, {
               ...command.options,
               stdin: {
                 ...stdinConfig,
@@ -10208,7 +10545,7 @@ var make18 = /* @__PURE__ */ gen2(function* () {
                 type: "input",
                 stream: sourceStream
               };
-              handles.push(yield* spawnCommand(make17(command.command, command.args, {
+              handles.push(yield* spawnCommand(make18(command.command, command.args, {
                 ...command.options,
                 additionalFds: {
                   ...existingFds,
@@ -10216,7 +10553,7 @@ var make18 = /* @__PURE__ */ gen2(function* () {
                 }
               })));
             } else {
-              handles.push(yield* spawnCommand(make17(command.command, command.args, {
+              handles.push(yield* spawnCommand(make18(command.command, command.args, {
                 ...command.options,
                 stdin: {
                   ...stdinConfig,
@@ -10255,9 +10592,9 @@ var make18 = /* @__PURE__ */ gen2(function* () {
       }
     }
   });
-  return make15(spawnCommand);
+  return make16(spawnCommand);
 });
-var layer = /* @__PURE__ */ effect(ChildProcessSpawner, make18);
+var layer = /* @__PURE__ */ effect(ChildProcessSpawner, make19);
 var flattenCommand = (command) => {
   const commands = [];
   const pipeOptions = [];
@@ -10307,7 +10644,7 @@ var bigintToNumber = (value, field) => {
 var bigintToNumberOption = (value) => flatMap(fromNullishOr(value), toNumber);
 var toUint64 = (value) => BigInt.asUintN(64, value);
 var toUint64Option = (value) => map(fromNullishOr(value), toUint64);
-var positionToNumber = (position, method) => try_2({
+var positionToNumber = (position, method) => try_3({
   try: () => bigintToNumber(position, "position"),
   catch: handleBadArgument(method)
 });
@@ -10429,7 +10766,7 @@ var noFollowFlags = (method, flag) => suspend2(() => {
 var openFactory = (method) => {
   const nodeOpen = effectify(NFS.open, handleErrnoException("FileSystem", method), handleBadArgument(method));
   const nodeClose = effectify(NFS.close, handleErrnoException("FileSystem", method), handleBadArgument(method));
-  return (path, options) => pipe(acquireRelease2(options?.noFollow === true ? flatMap3(noFollowFlags(method, options.flag ?? "r"), (flags) => nodeOpen(path, flags, options.mode)) : nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => orDie2(nodeClose(fd))), map5((fd) => makeFile(fd, options?.flag?.startsWith("a") ?? false)));
+  return (path, options) => pipe(acquireRelease2(options?.noFollow === true ? flatMap3(noFollowFlags(method, options.flag ?? "r"), (flags) => nodeOpen(path, flags, options.mode)) : nodeOpen(path, options?.flag ?? "r", options?.mode), (fd) => orDie2(nodeClose(fd))), map6((fd) => makeFile(fd, options?.flag?.startsWith("a") ?? false)));
 };
 var open2 = /* @__PURE__ */ openFactory("open");
 var negativePosition = (method) => badArgument({
@@ -10490,7 +10827,7 @@ var makeFile = /* @__PURE__ */ (() => {
           });
         }
         const position = this.position;
-        return map5(nodeRead(this.fd, {
+        return map6(nodeRead(this.fd, {
           buffer,
           position
         }), (bytesRead) => {
@@ -10511,7 +10848,7 @@ var makeFile = /* @__PURE__ */ (() => {
           }
           const buffer = Buffer.allocUnsafeSlow(size);
           const position = explicit ?? this.position;
-          return map5(nodeReadAlloc(this.fd, {
+          return map6(nodeReadAlloc(this.fd, {
             buffer,
             position
           }), (bytesRead) => {
@@ -10534,7 +10871,7 @@ var makeFile = /* @__PURE__ */ (() => {
       });
     }
     truncate(length) {
-      return map5(nodeTruncate(this.fd, length || undefined), () => {
+      return map6(nodeTruncate(this.fd, length || undefined), () => {
         if (!this.append) {
           const len = BigInt(length ?? 0);
           if (this.position > len) {
@@ -10546,7 +10883,7 @@ var makeFile = /* @__PURE__ */ (() => {
     write(buffer) {
       return suspend2(() => {
         const position = this.position;
-        return flatMap3(this.append ? succeed6(undefined) : positionToNumber(position, "write"), (nodePosition) => map5(nodeWrite(this.fd, buffer, undefined, undefined, nodePosition), (bytesWritten) => {
+        return flatMap3(this.append ? succeed6(undefined) : positionToNumber(position, "write"), (nodePosition) => map6(nodeWrite(this.fd, buffer, undefined, undefined, nodePosition), (bytesWritten) => {
           if (!this.append) {
             this.position = position + BigInt(bytesWritten);
           }
@@ -10608,7 +10945,7 @@ var readDirectoryEntries = (path) => tryPromise2({
     withFileTypes: true
   }),
   catch: (err) => handleErrnoException("FileSystem", "readDirectoryEntries")(err, [path])
-}).pipe(map5((entries) => entries.map((entry) => ({
+}).pipe(map6((entries) => entries.map((entry) => ({
   name: entry.name,
   type: fileType(entry)
 }))));
@@ -10640,7 +10977,7 @@ var rename2 = /* @__PURE__ */ (() => {
   return (oldPath, newPath) => nodeRename(oldPath, newPath);
 })();
 var fileType = (stat) => stat.isFile() ? "File" : stat.isDirectory() ? "Directory" : stat.isSymbolicLink() ? "SymbolicLink" : stat.isBlockDevice() ? "BlockDevice" : stat.isCharacterDevice() ? "CharacterDevice" : stat.isFIFO() ? "FIFO" : stat.isSocket() ? "Socket" : "Unknown";
-var makeFileInfo = (stat, method = "stat") => try_2({
+var makeFileInfo = (stat, method = "stat") => try_3({
   try: () => ({
     type: fileType(stat),
     mtime: fromNullishOr(stat.mtime),
@@ -10723,7 +11060,7 @@ var watchNode = (path, info, options) => callback3((queue) => acquireRelease2(sy
   });
   return watcher;
 }), (watcher) => sync2(() => watcher.close())).pipe(tap2(() => sync2(() => options?.onReady?.()))));
-var watch2 = (backend, path, options) => all2([stat2(path), serviceOption2(WatchBackend)]).pipe(map5(([stat, callerBackend]) => orElse(callerBackend, () => backend).pipe(flatMap((_) => _.register(path, stat, options)), getOrElse(() => watchNode(path, stat, options)))), unwrap3);
+var watch2 = (backend, path, options) => all2([stat2(path), serviceOption2(WatchBackend)]).pipe(map6(([stat, callerBackend]) => orElse(callerBackend, () => backend).pipe(flatMap((_) => _.register(path, stat, options)), getOrElse(() => watchNode(path, stat, options)))), unwrap3);
 var writeFile2 = (path, data, options) => callback2((resume, signal) => {
   try {
     NFS.writeFile(path, data, {
@@ -10741,7 +11078,7 @@ var writeFile2 = (path, data, options) => callback2((resume, signal) => {
     resume(fail7(handleBadArgument("writeFile")(err)));
   }
 });
-var makeFileSystem = /* @__PURE__ */ map5(/* @__PURE__ */ serviceOption2(WatchBackend), (backend) => make13({
+var makeFileSystem = /* @__PURE__ */ map6(/* @__PURE__ */ serviceOption2(WatchBackend), (backend) => make14({
   access: access2,
   chmod: chmod2,
   chown: chown2,
@@ -10780,7 +11117,7 @@ var layer3 = layer2;
 import * as NodePath from "path";
 import * as NodeUrl from "url";
 var fileUrlOps = (windows) => ({
-  fromFileUrl: (url) => try_2({
+  fromFileUrl: (url) => try_3({
     try: () => NodeUrl.fileURLToPath(url, {
       windows
     }),
@@ -10790,7 +11127,7 @@ var fileUrlOps = (windows) => ({
       cause
     })
   }),
-  toFileUrl: (path) => try_2({
+  toFileUrl: (path) => try_3({
     try: () => NodeUrl.pathToFileURL(path, {
       windows
     }),
@@ -10801,15 +11138,15 @@ var fileUrlOps = (windows) => ({
     })
   })
 });
-var layerPosix = /* @__PURE__ */ succeed5(Path)(/* @__PURE__ */ make14({
+var layerPosix = /* @__PURE__ */ succeed5(Path)(/* @__PURE__ */ make15({
   ...NodePath.posix,
   .../* @__PURE__ */ fileUrlOps(false)
 }));
-var layerWin32 = /* @__PURE__ */ succeed5(Path)(/* @__PURE__ */ make14({
+var layerWin32 = /* @__PURE__ */ succeed5(Path)(/* @__PURE__ */ make15({
   ...NodePath.win32,
   .../* @__PURE__ */ fileUrlOps(true)
 }));
-var layer4 = /* @__PURE__ */ succeed5(Path)(/* @__PURE__ */ make14({
+var layer4 = /* @__PURE__ */ succeed5(Path)(/* @__PURE__ */ make15({
   ...NodePath,
   .../* @__PURE__ */ fileUrlOps(undefined)
 }));
@@ -10820,7 +11157,7 @@ var layer5 = layer4;
 // node_modules/effect/dist/Stdio.js
 var TypeId22 = "~effect/Stdio";
 var Stdio = /* @__PURE__ */ Service(TypeId22);
-var make19 = (options) => ({
+var make20 = (options) => ({
   [TypeId22]: TypeId22,
   stdinIsTerminal: succeed6(false),
   stdoutIsTerminal: succeed6(false),
@@ -10829,7 +11166,7 @@ var make19 = (options) => ({
 });
 
 // node_modules/@effect/platform-node-shared/dist/NodeStdio.js
-var layer6 = /* @__PURE__ */ succeed5(Stdio, /* @__PURE__ */ make19({
+var layer6 = /* @__PURE__ */ succeed5(Stdio, /* @__PURE__ */ make20({
   args: /* @__PURE__ */ sync2(() => process.argv.slice(2)),
   stdinIsTerminal: /* @__PURE__ */ sync2(() => process.stdin.isTTY === true),
   stdoutIsTerminal: /* @__PURE__ */ sync2(() => process.stdout.isTTY === true),
@@ -10869,45 +11206,497 @@ var layer6 = /* @__PURE__ */ succeed5(Stdio, /* @__PURE__ */ make19({
 // node_modules/@effect/platform-bun/dist/BunStdio.js
 var layer7 = layer6;
 
-// node_modules/effect/dist/internal/schema/interpreter.js
-var flatMapTransformation = (result, current, f) => result === sameExit ? f(current) : flatMapEager2(result, f);
-function compileTransformation(transformation) {
-  const apply = compileTransformationUnsafe(transformation);
-  return (result, current, options) => {
-    try {
-      return apply(result, current, options);
-    } catch (error) {
-      return die3(error);
+// node_modules/effect/dist/http/Cookies.js
+var TypeId23 = "~effect/http/Cookies";
+var CookieTypeId = "~effect/http/Cookies/Cookie";
+var Proto4 = {
+  [TypeId23]: TypeId23,
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "effect/Cookies",
+      cookies: map2(this.cookies, (cookie) => cookie.toJSON())
+    };
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var fromReadonlyRecord = (cookies) => {
+  const self = Object.create(Proto4);
+  self.cookies = cookies;
+  return self;
+};
+var fromIterable2 = (cookies) => {
+  const record = {};
+  for (const cookie of cookies) {
+    assignProperty(record, cookie.name, cookie);
+  }
+  return fromReadonlyRecord(record);
+};
+var fromSetCookie = (headers) => {
+  const arrayHeaders = typeof headers === "string" ? [headers] : headers;
+  const cookies = [];
+  for (const header of arrayHeaders) {
+    const cookie = parseSetCookie(header.trim());
+    if (cookie) {
+      cookies.push(cookie);
     }
-  };
+  }
+  return fromIterable2(cookies);
+};
+function parseSetCookie(header) {
+  const parts = header.split(";").map((_) => _.trim()).filter((_) => _ !== "");
+  if (parts.length === 0) {
+    return;
+  }
+  const firstEqual = parts[0].indexOf("=");
+  if (firstEqual === -1) {
+    return;
+  }
+  const name = parts[0].slice(0, firstEqual).replace(cookieWhitespaceRegExp, "");
+  if (!cookieNameRegExp.test(name)) {
+    return;
+  }
+  const valueEncoded = parts[0].slice(firstEqual + 1).replace(cookieWhitespaceRegExp, "");
+  const value = tryDecodeURIComponent(valueEncoded);
+  if (parts.length === 1) {
+    return Object.assign(Object.create(CookieProto), {
+      name,
+      value,
+      valueEncoded
+    });
+  }
+  const options = {};
+  for (let i = 1;i < parts.length; i++) {
+    const part = parts[i];
+    const equalIndex = part.indexOf("=");
+    const key = equalIndex === -1 ? part : part.slice(0, equalIndex).trim();
+    const value = equalIndex === -1 ? undefined : part.slice(equalIndex + 1).trim();
+    switch (key.toLowerCase()) {
+      case "domain": {
+        if (value === undefined) {
+          break;
+        }
+        const domain = value.trim().replace(/^\./, "");
+        if (domain) {
+          options.domain = domain;
+        }
+        break;
+      }
+      case "expires": {
+        if (value === undefined) {
+          break;
+        }
+        const date = new Date(value);
+        if (!isNaN(date.getTime())) {
+          options.expires = date;
+        }
+        break;
+      }
+      case "max-age": {
+        if (value === undefined || !maxAgeRegExp.test(value)) {
+          break;
+        }
+        options.maxAge = seconds(parseInt(value, 10));
+        break;
+      }
+      case "path": {
+        if (value === undefined) {
+          break;
+        }
+        if (value[0] === "/") {
+          options.path = value;
+        }
+        break;
+      }
+      case "priority": {
+        if (value === undefined) {
+          break;
+        }
+        switch (value.toLowerCase()) {
+          case "low":
+            options.priority = "low";
+            break;
+          case "medium":
+            options.priority = "medium";
+            break;
+          case "high":
+            options.priority = "high";
+            break;
+        }
+        break;
+      }
+      case "httponly": {
+        options.httpOnly = true;
+        break;
+      }
+      case "secure": {
+        options.secure = true;
+        break;
+      }
+      case "partitioned": {
+        options.partitioned = true;
+        break;
+      }
+      case "samesite": {
+        if (value === undefined) {
+          break;
+        }
+        switch (value.toLowerCase()) {
+          case "lax":
+            options.sameSite = "lax";
+            break;
+          case "strict":
+            options.sameSite = "strict";
+            break;
+          case "none":
+            options.sameSite = "none";
+            break;
+        }
+        break;
+      }
+    }
+  }
+  return Object.assign(Object.create(CookieProto), {
+    name,
+    value,
+    valueEncoded,
+    options: Object.keys(options).length > 0 ? options : undefined
+  });
 }
-function compileTransformationUnsafe(transformation) {
-  if (transformation._tag === "Middleware") {
-    return (result, current, options) => {
-      const transformed = result === sameExit ? transformation.decode(succeed8(toOption(current)), options) : transformation.decode(mapEager2(result, toOption), options);
-      return fromOptionalEffect(transformed);
+var cookieNameRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var cookieWhitespaceRegExp = /^[\t ]+|[\t ]+$/g;
+var maxAgeRegExp = /^-?[0-9]+$/;
+var CookieProto = {
+  [CookieTypeId]: CookieTypeId,
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "effect/Cookies/Cookie",
+      name: this.name,
+      value: this.value,
+      options: this.options
     };
   }
-  const getter = transformation.decode;
-  switch (getter._tag) {
-    case "Passthrough":
-      return (result, current) => result === sameExit ? succeed8(current) : result;
-    case "Transform": {
-      const transform = (value) => value === missing ? missingExit : succeed8(getter.transform(value));
-      return (result, current) => flatMapTransformation(result, current, transform);
+};
+var tryDecodeURIComponent = (str) => {
+  try {
+    return decodeURIComponent(str);
+  } catch (_) {
+    return str;
+  }
+};
+
+// node_modules/effect/dist/http/Headers.js
+var TypeId24 = /* @__PURE__ */ Symbol.for("~effect/http/Headers");
+var Proto5 = /* @__PURE__ */ Object.defineProperties(/* @__PURE__ */ Object.create(null), {
+  [TypeId24]: {
+    value: TypeId24
+  },
+  [symbolRedactable]: {
+    value(context) {
+      return redact2(this, get(context, CurrentRedactedNames));
     }
-    case "TransformOptional": {
-      const transform = (value) => fromOptionExit(getter.transform(toOption(value)));
-      return (result, current) => flatMapTransformation(result, current, transform);
+  },
+  toJSON: {
+    value() {
+      return redact(this);
     }
-    case "TransformEffect":
-      return (result, current, options) => flatMapTransformation(result, current, (value) => value === missing ? missingExit : getter.transform(value, options));
-    case "TransformOptionalEffect":
-      return (result, current, options) => flatMapTransformation(result, current, (value) => fromOptionalEffect(getter.transform(toOption(value), options)));
+  },
+  [symbol2]: {
+    value(that) {
+      return Equivalence2(this, that);
+    }
+  },
+  [symbol]: {
+    value() {
+      return structure(this);
+    }
+  },
+  toString: {
+    value: BaseProto.toString
+  },
+  [NodeInspectSymbol]: {
+    value: BaseProto[NodeInspectSymbol]
   }
-}
+});
+var make21 = (input) => Object.assign(Object.create(Proto5), input);
+var Equivalence2 = /* @__PURE__ */ makeEquivalence2(/* @__PURE__ */ strictEqual());
+var empty5 = /* @__PURE__ */ Object.create(Proto5);
+var fromInput = (input) => {
+  if (input === undefined) {
+    return empty5;
+  } else if (Symbol.iterator in input) {
+    const out = Object.create(Proto5);
+    for (const [k, v] of input) {
+      out[k.toLowerCase()] = v;
+    }
+    return out;
+  }
+  const out = Object.create(Proto5);
+  for (const [k, v] of Object.entries(input)) {
+    if (Array.isArray(v)) {
+      out[k.toLowerCase()] = v.join(", ");
+    } else if (v !== undefined) {
+      out[k.toLowerCase()] = v;
+    }
+  }
+  return out;
+};
+var fromRecordUnsafe = (input) => Object.setPrototypeOf(input, Proto5);
+var set2 = /* @__PURE__ */ dual(3, (self, key, value) => {
+  const out = make21(self);
+  out[key.toLowerCase()] = value;
+  return out;
+});
+var setAll = /* @__PURE__ */ dual(2, (self, headers) => make21({
+  ...self,
+  ...fromInput(headers)
+}));
+var merge4 = /* @__PURE__ */ dual(2, (self, headers) => {
+  const out = make21(self);
+  Object.assign(out, headers);
+  return out;
+});
+var remove3 = /* @__PURE__ */ dual(2, (self, key) => {
+  const out = make21(self);
+  delete out[key.toLowerCase()];
+  return out;
+});
+var redact2 = /* @__PURE__ */ dual(2, (self, key) => {
+  const out = {
+    ...self
+  };
+  const modify = (key) => {
+    if (typeof key === "string") {
+      const k = key.toLowerCase();
+      if (k in self) {
+        out[k] = make17(self[k]);
+      }
+    } else {
+      for (const name in self) {
+        if (name.search(key) !== -1) {
+          out[name] = make17(self[name]);
+        }
+      }
+    }
+  };
+  if (Array.isArray(key)) {
+    for (let i = 0;i < key.length; i++) {
+      modify(key[i]);
+    }
+  } else {
+    modify(key);
+  }
+  return out;
+});
+var isRedactedName = (name, patterns) => {
+  const lowerName = name.toLowerCase();
+  for (let i = 0;i < patterns.length; i++) {
+    const pattern = patterns[i];
+    if (typeof pattern === "string") {
+      if (pattern.toLowerCase() === lowerName) {
+        return true;
+      }
+    } else if (name.search(pattern) !== -1) {
+      return true;
+    }
+  }
+  return false;
+};
+var CurrentRedactedNames = /* @__PURE__ */ Reference("effect/Headers/CurrentRedactedNames", {
+  defaultValue: () => ["authorization", "cookie", "set-cookie", "x-api-key"]
+});
+
+// node_modules/effect/dist/http/internal/urlParams.js
+var unwrap6 = (value) => typeof value === "string" ? value : value2(value);
+var bodyDecoder = /* @__PURE__ */ new TextDecoder("utf-8", {
+  ignoreBOM: true
+});
+var fromBody = (bytes) => new URLSearchParams(bodyDecoder.decode(bytes).replace(/^\?/, "%3F"));
+
+// node_modules/effect/dist/http/UrlParams.js
+var TypeId25 = "~effect/http/UrlParams";
+var isUrlParams = (u) => hasProperty(u, TypeId25);
+var Proto6 = {
+  ...PipeInspectableProto,
+  [TypeId25]: TypeId25,
+  [Symbol.iterator]() {
+    return this.params[Symbol.iterator]();
+  },
+  [symbolRedactable](context) {
+    return {
+      _id: "UrlParams",
+      params: Object.fromEntries(redact3(this, get(context, CurrentRedactedNames2)))
+    };
+  },
+  toJSON() {
+    return redact(this);
+  },
+  [symbol2](that) {
+    return Equivalence3(this, that);
+  },
+  [symbol]() {
+    return array(this.params.flat());
+  }
+};
+var make22 = (params) => {
+  const self = Object.create(Proto6);
+  self.params = params;
+  return self;
+};
+var fromInput2 = (input) => {
+  if (isUrlParams(input)) {
+    return input;
+  }
+  const parsed = fromInputNested(input);
+  const out = [];
+  for (let i = 0;i < parsed.length; i++) {
+    if (Array.isArray(parsed[i][0])) {
+      const [keys, value] = parsed[i];
+      out.push([`${keys[0]}[${keys.slice(1).join("][")}]`, value]);
+    } else {
+      out.push(parsed[i]);
+    }
+  }
+  return make22(out);
+};
+var fromInputNested = (input) => {
+  const entries = typeof input[Symbol.iterator] === "function" ? fromIterable(input) : Object.entries(input);
+  const out = [];
+  for (const [key, value] of entries) {
+    if (Array.isArray(value)) {
+      for (let i = 0;i < value.length; i++) {
+        if (value[i] !== undefined) {
+          out.push([key, coerce(value[i])]);
+        }
+      }
+    } else if (value !== null && typeof value === "object" && !isRedacted(value)) {
+      const nested = fromInputNested(value);
+      for (const [k, v] of nested) {
+        out.push([[key, ...typeof k === "string" ? [k] : k], v]);
+      }
+    } else if (value !== undefined) {
+      out.push([key, coerce(value)]);
+    }
+  }
+  return out;
+};
+var coerce = (value) => isRedacted(value) ? value : String(value);
+var Equivalence3 = /* @__PURE__ */ make((a, b) => arrayEquivalence(a.params, b.params));
+var arrayEquivalence = /* @__PURE__ */ makeEquivalence3(/* @__PURE__ */ makeEquivalence([/* @__PURE__ */ strictEqual(), /* @__PURE__ */ asEquivalence()]));
+var empty6 = /* @__PURE__ */ make22([]);
+var setAll2 = /* @__PURE__ */ dual(2, (self, input) => {
+  const params = fromInput2(input).params.slice();
+  const keys = new Set;
+  for (let i = 0;i < params.length; i++) {
+    keys.add(params[i][0]);
+  }
+  for (let i = 0;i < self.params.length; i++) {
+    if (keys.has(self.params[i][0]))
+      continue;
+    params.push(self.params[i]);
+  }
+  return make22(params);
+});
+var redact3 = /* @__PURE__ */ dual(2, (self, key) => {
+  const patterns = Array.isArray(key) ? key : [key];
+  return self.params.map(([name, value]) => [name, typeof value === "string" && isRedactedName2(name, patterns) ? make17(value) : value]);
+});
+var isRedactedName2 = isRedactedName;
+var redactUrl = (url, redactedNames = currentRedactedNames()) => {
+  if (url.includes("@"))
+    url = redactUserinfo(url);
+  const queryStart = url.indexOf("?");
+  if (queryStart === -1 || redactedNames.length === 0)
+    return url;
+  const hashStart = url.indexOf("#");
+  if (hashStart !== -1 && hashStart < queryStart)
+    return url;
+  const queryEnd = hashStart === -1 ? url.length : hashStart;
+  return url.slice(0, queryStart + 1) + redactQuery(url.slice(queryStart + 1, queryEnd), redactedNames) + url.slice(queryEnd);
+};
+var authorityStart = /^(?:(https?|ftp|wss?):[/\\]*|[a-z][a-z\d+.-]*:\/\/|[/\\]{2,})/i;
+var specialAuthorityEnd = /[/\\?#]/;
+var authorityEnd = /[/?#]/;
+var redactUserinfo = (url) => {
+  let normalized = "";
+  const offsets = [];
+  for (let i = 0;i < url.length; i++) {
+    const code = url.charCodeAt(i);
+    if (code === 9 || code === 10 || code === 13 || normalized === "" && code <= 32)
+      continue;
+    normalized += url[i];
+    offsets.push(i);
+  }
+  const authority = authorityStart.exec(normalized);
+  if (authority === null)
+    return url;
+  const start = authority[0].length;
+  const special = authority[1] !== undefined || !authority[0].includes(":");
+  const rest = normalized.slice(start);
+  const end = rest.search(special ? specialAuthorityEnd : authorityEnd);
+  const userinfoEnd = (end === -1 ? rest : rest.slice(0, end)).lastIndexOf("@");
+  return userinfoEnd === -1 ? url : url.slice(0, offsets[start]) + "REDACTED:REDACTED" + url.slice(offsets[start + userinfoEnd]);
+};
+var redactQuery = (query, redactedNames) => query.split("&").map((part) => {
+  const index = part.indexOf("=");
+  return index !== -1 && isRedactedName2(decodeQueryKey(part.slice(0, index)), redactedNames) ? part.slice(0, index + 1) + "REDACTED" : part;
+}).join("&");
+var decodeQueryKey = (key) => {
+  if (!key.includes("%") && !key.includes("+"))
+    return key;
+  try {
+    return decodeURIComponent(key.replace(/\+/g, " "));
+  } catch {
+    return key;
+  }
+};
+var currentRedactedNames = () => get(globalThis[currentFiberTypeId]?.context ?? empty(), CurrentRedactedNames2);
+var CurrentRedactedNames2 = /* @__PURE__ */ Reference("effect/http/UrlParams/CurrentRedactedNames", {
+  defaultValue: () => ["X-Amz-Signature", "X-Amz-Credential", "X-Amz-Security-Token", "AWSAccessKeyId", "Signature", "sig", "X-Goog-Signature"]
+});
+
+// node_modules/effect/dist/internal/schema/interpreter.js
+var flatMapTransformation = (result, current, f) => result === sameExit ? f(current) : flatMapEager2(result, f);
+function compileTransformation(transformation) {
+  const apply = compileTransformationUnsafe(transformation);
+  return (result, current, options) => {
+    try {
+      return apply(result, current, options);
+    } catch (error) {
+      return die3(error);
+    }
+  };
+}
+function compileTransformationUnsafe(transformation) {
+  if (transformation._tag === "Middleware") {
+    return (result, current, options) => {
+      const transformed = result === sameExit ? transformation.decode(succeed8(toOption(current)), options) : transformation.decode(mapEager2(result, toOption), options);
+      return fromOptionalEffect(transformed);
+    };
+  }
+  const getter = transformation.decode;
+  switch (getter._tag) {
+    case "Passthrough":
+      return (result, current) => result === sameExit ? succeed8(current) : result;
+    case "Transform": {
+      const transform = (value) => value === missing ? missingExit : succeed8(getter.transform(value));
+      return (result, current) => flatMapTransformation(result, current, transform);
+    }
+    case "TransformOptional": {
+      const transform = (value) => fromOptionExit(getter.transform(toOption(value)));
+      return (result, current) => flatMapTransformation(result, current, transform);
+    }
+    case "TransformEffect":
+      return (result, current, options) => flatMapTransformation(result, current, (value) => value === missing ? missingExit : getter.transform(value, options));
+    case "TransformOptionalEffect":
+      return (result, current, options) => flatMapTransformation(result, current, (value) => fromOptionalEffect(getter.transform(toOption(value), options)));
+  }
+}
 var fromOptionalEffect = (effect) => flatMapEager2(effect, fromOptionExit);
-var wrapEncoding = (ast, input, options, effect) => catchCause2(effect, (cause) => failCauseSync2(() => map4(cause, (issue) => new Encoding(ast, issue, input, options))));
+var wrapEncoding = (ast, input, options, effect) => catchCause2(effect, (cause) => failCauseSync2(() => map5(cause, (issue) => new Encoding(ast, issue, input, options))));
 function makeConstructorParser(descriptor, compile) {
   const transform = compileTransformation(descriptor.link.transformation);
   let sourceParser;
@@ -11171,7 +11960,7 @@ function makeOption(schema) {
     return none2();
   };
 }
-function make20(schema) {
+function make23(schema) {
   return makeConstructorSync(toType(schema.ast));
 }
 function is(schema) {
@@ -11261,7 +12050,7 @@ function runWithCompiler(compiler, ast) {
 function asExit(parser) {
   return (input, options) => runSyncExit2(parser(input, options));
 }
-function runSync2(effect, message) {
+function runSync3(effect, message) {
   const exit = runSyncExit2(effect);
   if (isSuccess3(exit)) {
     return exit.value;
@@ -11299,7 +12088,7 @@ function constructSync(entry, input, options) {
     if (output !== invalid3 && output !== missing)
       return output;
   }
-  return runSync2(parserResult(entry.makeEffect(input, parseOptions), input), constructorDefectMessage);
+  return runSync3(parserResult(entry.makeEffect(input, parseOptions), input), constructorDefectMessage);
 }
 function makeClassSync(ast, input, options, construct) {
   const entry = resolve3(ast);
@@ -11320,12 +12109,12 @@ var normalCompiler = (ast) => resolve3(ast).parser;
 var constructorCompiler = (ast) => resolve3(ast).makeEffect;
 
 // node_modules/effect/dist/internal/schema/make.js
-var TypeId23 = "~effect/Schema/Schema";
+var TypeId26 = "~effect/Schema/Schema";
 var RebuildOptions = /* @__PURE__ */ Symbol();
 var SchemaProto = {
-  [TypeId23]: TypeId23,
+  [TypeId26]: TypeId26,
   get make() {
-    const value = make20(this);
+    const value = make23(this);
     Object.defineProperty(this, "make", {
       value,
       enumerable: true
@@ -11361,10 +12150,10 @@ var SchemaProto = {
     return this.rebuild(appendChecks(this.ast, checks));
   },
   rebuild(ast) {
-    return make21(ast, this[RebuildOptions]);
+    return make24(ast, this[RebuildOptions]);
   }
 };
-function make21(ast, options) {
+function make24(ast, options) {
   function Schema() {}
   const self = Object.setPrototypeOf(Schema, SchemaProto);
   if (options && (Object.hasOwn(options, "name") || Object.hasOwn(options, "length") || Object.hasOwn(options, "__proto__"))) {
@@ -11415,7 +12204,7 @@ function makeReorder(getPriority) {
   };
 }
 function toCodecStringTree(schema) {
-  return make21(toCodecStringTreeAST(schema.ast), {
+  return make24(toCodecStringTreeAST(schema.ast), {
     schema
   });
 }
@@ -11435,7 +12224,7 @@ var toStringTreeReorder = /* @__PURE__ */ makeReorder((ast) => {
 function toCodecStringTreeASTStep(ast, recur, onMissingAnnotation) {
   switch (ast._tag) {
     case "Declaration": {
-      const typeParameters = ast.typeParameters.map((tp) => make21(recur(toEncoded(tp))));
+      const typeParameters = ast.typeParameters.map((tp) => make24(recur(toEncoded(tp))));
       const getStringTreeLink = ast.annotations?.toCodecStringTree;
       if (isFunction(getStringTreeLink)) {
         const link = getStringTreeLink(typeParameters);
@@ -11499,10 +12288,10 @@ var lambda = (f) => f;
 var SchemaErrorTypeId = "~effect/Schema/SchemaError";
 
 // node_modules/effect/dist/Schema.js
-var TypeId24 = TypeId23;
+var TypeId27 = TypeId26;
 function declareConstructor() {
   return (typeParameters, run, annotations) => {
-    return make22(new Declaration(typeParameters.map(getAST), (typeParameters) => run(typeParameters.map((ast) => make22(ast))), annotations));
+    return make25(new Declaration(typeParameters.map(getAST), (typeParameters) => run(typeParameters.map((ast) => make25(ast))), annotations));
   };
 }
 function declare(is, annotations) {
@@ -11541,10 +12330,10 @@ function fromIssueEffect(self) {
   if (effectIsExit(self)) {
     return fromIssueExit(self);
   }
-  return catchCause2(self, (cause) => failCauseSync2(() => map4(cause, (issue) => new SchemaError(issue))));
+  return catchCause2(self, (cause) => failCauseSync2(() => map5(cause, (issue) => new SchemaError(issue))));
 }
 function fromIssueExit(exit) {
-  return isSuccess3(exit) ? exit : failCause2(map4(exit.cause, (issue) => new SchemaError(issue)));
+  return isSuccess3(exit) ? exit : failCause2(map5(exit.cause, (issue) => new SchemaError(issue)));
 }
 var is2 = is;
 function decodeUnknownEffect2(schema, options) {
@@ -11554,21 +12343,21 @@ function decodeUnknownEffect2(schema, options) {
   };
 }
 var decodeEffect2 = decodeUnknownEffect2;
-var make22 = make21;
+var make25 = make24;
 function isSchema(u) {
-  return hasProperty(u, TypeId24) && u[TypeId24] === TypeId24;
+  return hasProperty(u, TypeId27) && u[TypeId27] === TypeId27;
 }
-var optionalKey2 = /* @__PURE__ */ lambda((schema) => make22(optionalKey(schema.ast), {
+var optionalKey2 = /* @__PURE__ */ lambda((schema) => make25(optionalKey(schema.ast), {
   schema
 }));
 var optional2 = /* @__PURE__ */ lambda((self) => {
   const schema = UndefinedOr(self);
-  return make22(optional(self.ast), {
+  return make25(optional(self.ast), {
     schema
   });
 });
 function Literal2(literal) {
-  const out = make22(new Literal(literal), {
+  const out = make25(new Literal(literal), {
     literal,
     transform(to) {
       return out.pipe(decodeTo2(Literal2(to), {
@@ -11579,13 +12368,13 @@ function Literal2(literal) {
   });
   return out;
 }
-var Unknown2 = /* @__PURE__ */ make22(unknown);
-var Undefined2 = /* @__PURE__ */ make22(undefined_2);
-var String5 = /* @__PURE__ */ make22(string2);
-var Number6 = /* @__PURE__ */ make22(number2);
-var Boolean3 = /* @__PURE__ */ make22(boolean);
+var Unknown2 = /* @__PURE__ */ make25(unknown);
+var Undefined2 = /* @__PURE__ */ make25(undefined_2);
+var String5 = /* @__PURE__ */ make25(string2);
+var Number6 = /* @__PURE__ */ make25(number2);
+var Boolean3 = /* @__PURE__ */ make25(boolean);
 function makeStruct(ast, fields) {
-  return make22(ast, {
+  return make25(ast, {
     fields,
     mapFields(f, options) {
       const fields = f(this.fields);
@@ -11597,16 +12386,16 @@ function Struct(fields) {
   return makeStruct(struct(fields, undefined), fields);
 }
 function Record(key, value) {
-  return make22(record(key.ast, value.ast), {
+  return make25(record(key.ast, value.ast), {
     key,
     value
   });
 }
-var ArraySchema = /* @__PURE__ */ lambda((schema) => make22(new Arrays(false, [], [schema.ast]), {
+var ArraySchema = /* @__PURE__ */ lambda((schema) => make25(new Arrays(false, [], [schema.ast]), {
   value: schema
 }));
 function makeUnion(ast, members) {
-  return make22(ast, {
+  return make25(ast, {
     members,
     mapMembers(f, options) {
       const members = f(this.members);
@@ -11619,7 +12408,7 @@ function Union2(members, options) {
 }
 function Literals(literals) {
   const members = literals.map(Literal2);
-  return make22(union2(members, undefined, undefined), {
+  return make25(union2(members, undefined, undefined), {
     literals,
     members,
     mapMembers(f) {
@@ -11636,7 +12425,7 @@ function Literals(literals) {
 var UndefinedOr = /* @__PURE__ */ lambda((self) => Union2([self, Undefined2]));
 function decodeTo2(to, transformation) {
   return (from) => {
-    return make22(decodeTo(from.ast, to.ast, transformation ? makeTransformation(transformation) : passthrough2()), {
+    return make25(decodeTo(from.ast, to.ast, transformation ? makeTransformation(transformation) : passthrough2()), {
       from,
       to
     });
@@ -11649,7 +12438,7 @@ var BooleanLiterals = /* @__PURE__ */ Literals([...TrueLiterals.literals, ...Fal
   encode: (value) => value ? "true" : "false"
 })));
 function withConstructorDefault2(defaultValue) {
-  return (schema) => make22(withConstructorDefault(schema.ast, defaultValue), {
+  return (schema) => make25(withConstructorDefault(schema.ast, defaultValue), {
     schema
   });
 }
@@ -11710,6 +12499,45 @@ function isBase64(annotations) {
     ...annotations
   });
 }
+function makeIsGreaterThan(options) {
+  const gt = isGreaterThan(options.order);
+  const formatter = options.formatter ?? format;
+  return (exclusiveMinimum, annotations) => {
+    return makeFilter2((input) => gt(input, exclusiveMinimum), {
+      expected: `a value greater than ${formatter(exclusiveMinimum)}`,
+      arbitraryConstraint: {
+        order: options.order,
+        minimum: exclusiveMinimum,
+        exclusiveMinimum: true
+      },
+      ...options.annotate?.(exclusiveMinimum),
+      ...annotations
+    });
+  };
+}
+function encodeNumberPayload(number) {
+  if (!globalThis.Number.isFinite(number)) {
+    throw new globalThis.RangeError(`Expected a finite number, got ${format(number)}`);
+  }
+  return number;
+}
+var isGreaterThan2 = /* @__PURE__ */ makeIsGreaterThan({
+  order: Number2,
+  annotate: (exclusiveMinimum) => ({
+    representation: {
+      id: "effect/schema/isGreaterThan",
+      payload: {
+        exclusiveMinimum: encodeNumberPayload(exclusiveMinimum)
+      }
+    },
+    toJsonSchema: () => ({
+      exclusiveMinimum
+    }),
+    toCode: () => ({
+      runtime: `Schema.isGreaterThan(${format(exclusiveMinimum)})`
+    })
+  })
+});
 function isInt(annotations) {
   return makeFilter2((n) => globalThis.Number.isSafeInteger(n), {
     expected: "an integer",
@@ -11812,7 +12640,7 @@ var RegExp2 = /* @__PURE__ */ instanceOf(globalThis.RegExp, {
     source: String5,
     flags: String5
   }), transformEffect2({
-    decode: (e, options) => try_2({
+    decode: (e, options) => try_3({
       try: () => new globalThis.RegExp(e.source, e.flags),
       catch: () => new InvalidValue({
         expected: "valid RegExp source and flags"
@@ -11839,6 +12667,7 @@ var URL2 = /* @__PURE__ */ instanceOf(globalThis.URL, {
   expected: "URL",
   toCodecJson: () => link3()(URLString, urlFromString)
 });
+var URLFromString = /* @__PURE__ */ URLString.pipe(/* @__PURE__ */ decodeTo2(URL2, urlFromString));
 var File = /* @__PURE__ */ instanceOf(globalThis.File, {
   representation: {
     id: "effect/schema/File",
@@ -11942,7 +12771,7 @@ function makeClass(Inherited, identifier, struct2, annotations, proto) {
         }
       });
     }
-    static [TypeId24] = TypeId24;
+    static [TypeId27] = TypeId27;
     get [ClassTypeId]() {
       return ClassTypeId;
     }
@@ -12021,7 +12850,7 @@ function getClassSchemaFactory(from, identifier, annotations) {
     const ClassTypeId = getClassTypeId(identifier);
     const isClassValue = (input) => input instanceof self || hasProperty(input, ClassTypeId);
     const transformation = getClassTransformation(self);
-    const to = make22(new Declaration([from.ast], () => (input, ast, options) => {
+    const to = make25(new Declaration([from.ast], () => (input, ast, options) => {
       return isClassValue(input) ? succeed6(input) : fail7(new InvalidType(ast, input, options));
     }, {
       identifier,
@@ -12060,7 +12889,7 @@ var TaggedError3 = (identifier) => {
   };
 };
 var toCodecStringTree2 = toCodecStringTree;
-var Json2 = /* @__PURE__ */ make22(/* @__PURE__ */ annotate(Json, {
+var Json2 = /* @__PURE__ */ make25(/* @__PURE__ */ annotate(Json, {
   toCode: () => ({
     runtime: "Schema.Json",
     Type: "Schema.Json"
@@ -12068,7 +12897,7 @@ var Json2 = /* @__PURE__ */ make22(/* @__PURE__ */ annotate(Json, {
 }));
 
 // node_modules/effect/dist/Terminal.js
-var TypeId25 = "~effect/Terminal";
+var TypeId28 = "~effect/Terminal";
 var QuitErrorTypeId = "~effect/Terminal/QuitError";
 
 class QuitError extends (/* @__PURE__ */ Error4("QuitError")({
@@ -12078,17 +12907,17 @@ class QuitError extends (/* @__PURE__ */ Error4("QuitError")({
 }
 var isQuitError = (u) => hasProperty(u, QuitErrorTypeId);
 var Terminal = /* @__PURE__ */ Service("effect/Terminal");
-var make23 = (impl) => Terminal.of({
+var make26 = (impl) => Terminal.of({
   ...impl,
-  [TypeId25]: TypeId25
+  [TypeId28]: TypeId28
 });
 
 // node_modules/@effect/platform-node-shared/dist/NodeTerminal.js
 import * as readline from "readline";
-var make24 = /* @__PURE__ */ fnUntraced2(function* (shouldQuit = defaultShouldQuit) {
+var make27 = /* @__PURE__ */ fnUntraced2(function* (shouldQuit = defaultShouldQuit) {
   const stdin = process.stdin;
   const stdout = process.stdout;
-  const lines = yield* make9();
+  const lines = yield* make10();
   let inputEnded = stdin.readableEnded;
   let readlineActive = false;
   const onStdinEnd = () => {
@@ -12099,7 +12928,7 @@ var make24 = /* @__PURE__ */ fnUntraced2(function* (shouldQuit = defaultShouldQu
   };
   stdin.once("end", onStdinEnd);
   yield* addFinalizer3(() => sync2(() => stdin.off("end", onStdinEnd)));
-  const rlRef = yield* make11({
+  const rlRef = yield* make12({
     acquire: acquireRelease2(sync2(() => {
       const rl = readline.createInterface({
         input: stdin,
@@ -12138,7 +12967,7 @@ var make24 = /* @__PURE__ */ fnUntraced2(function* (shouldQuit = defaultShouldQu
     if (stdin.isTTY)
       stdin.setRawMode(enabled);
   });
-  const rawModeRef = yield* make11({
+  const rawModeRef = yield* make12({
     acquire: acquireRelease2(setRawMode(true), () => setRawMode(false)),
     idleTimeToLive: "10 millis"
   });
@@ -12159,7 +12988,7 @@ var make24 = /* @__PURE__ */ fnUntraced2(function* (shouldQuit = defaultShouldQu
     return queue;
   });
   const readInput = gen2(function* () {
-    const queue = yield* make9();
+    const queue = yield* make10();
     const handleKeypress = (s, k) => {
       const userInput = {
         input: fromUndefinedOr(s),
@@ -12207,7 +13036,7 @@ var make24 = /* @__PURE__ */ fnUntraced2(function* (shouldQuit = defaultShouldQu
       cause: err
     }))));
   }));
-  return make23({
+  return make26({
     columns,
     rows,
     size,
@@ -12216,7 +13045,7 @@ var make24 = /* @__PURE__ */ fnUntraced2(function* (shouldQuit = defaultShouldQu
     display
   });
 });
-var layer8 = /* @__PURE__ */ effect(Terminal, /* @__PURE__ */ make24(defaultShouldQuit));
+var layer8 = /* @__PURE__ */ effect(Terminal, /* @__PURE__ */ make27(defaultShouldQuit));
 function defaultShouldQuit(input) {
   const key = input.key;
   return key.name === "escape" || key.ctrl && (key.name === "c" || key.name === "d");
@@ -12251,7 +13080,7 @@ function makeArray(length, value) {
 var ConfigProvider = /* @__PURE__ */ Reference("effect/ConfigProvider", {
   defaultValue: () => fromEnv()
 });
-var Proto4 = {
+var Proto7 = {
   ...PipeInspectableProto,
   toJSON() {
     return {
@@ -12261,7 +13090,7 @@ var Proto4 = {
 };
 var identityPath = (path) => path;
 function makeProvider(load, mapInput) {
-  const self = Object.create(Proto4);
+  const self = Object.create(Proto7);
   self.load = load;
   self.mapInput = mapInput;
   return self;
@@ -12269,7 +13098,7 @@ function makeProvider(load, mapInput) {
 function makeSource(get, transform) {
   return makeProvider((path) => get(transform(path)), (f) => makeSource(get, (path) => f(transform(path))));
 }
-function make25(get) {
+function make28(get) {
   return makeSource(get, identityPath);
 }
 function emptyStringAsMissing(value, preserveEmptyStrings) {
@@ -12278,7 +13107,7 @@ function emptyStringAsMissing(value, preserveEmptyStrings) {
 function fromEnvRecord(env, options) {
   const preserveEmptyStrings = options?.preserveEmptyStrings === true;
   const trie = buildEnvTrie(env);
-  return make25((path) => succeed6(nodeAtEnv(trie, env, path, preserveEmptyStrings)));
+  return make28((path) => succeed6(nodeAtEnv(trie, env, path, preserveEmptyStrings)));
 }
 function fromEnv(options) {
   const env = options?.env ?? {
@@ -12331,7 +13160,7 @@ function trieNodeAt(root, path) {
 }
 
 // node_modules/effect/dist/Config.js
-var TypeId26 = "~effect/Config";
+var TypeId29 = "~effect/Config";
 class ConfigError {
   _tag = "ConfigError";
   name = "ConfigError";
@@ -12346,29 +13175,29 @@ class ConfigError {
     return `ConfigError(${this.message})`;
   }
 }
-var Proto5 = {
+var Proto8 = {
   .../* @__PURE__ */ Prototype2({
     label: "Config",
     evaluate(fiber) {
       return this.parse(fiber.getRef(ConfigProvider));
     }
   }),
-  [TypeId26]: TypeId26,
+  [TypeId29]: TypeId29,
   toJSON() {
     return {
       _id: "Config"
     };
   }
 };
-function make26(evaluator) {
-  const self = Object.create(Proto5);
+function make29(evaluator) {
+  const self = Object.create(Proto8);
   self.evaluator = evaluator;
   self.parse = (provider) => flatMapEager2(evaluator(provider, []), fromResult2);
   return self;
 }
 var evaluateAt = (self, provider, pathPrefix) => self.evaluator(provider, pathPrefix);
 var withDefault3 = /* @__PURE__ */ dual(2, (self, defaultValue) => {
-  return make26((provider, pathPrefix) => mapEager2(evaluateAt(self, provider, pathPrefix), (resolution) => isFailure2(resolution) ? succeed2(defaultValue) : resolution));
+  return make29((provider, pathPrefix) => mapEager2(evaluateAt(self, provider, pathPrefix), (resolution) => isFailure2(resolution) ? succeed2(defaultValue) : resolution));
 });
 var isSourceError = (u) => isTagged(u, "SourceError");
 var cursorToString = () => "<configuration>";
@@ -12484,9 +13313,9 @@ var toConfigCursorAST = /* @__PURE__ */ memoize((root) => {
 function schema(codec, path) {
   const codecStringTree = toCodecStringTree2(codec);
   const encodedAst = toEncoded(codecStringTree.ast);
-  const decodeCursor = decodeUnknownEffect(make22(toConfigCursorAST(codecStringTree.ast)));
+  const decodeCursor = decodeUnknownEffect(make25(toConfigCursorAST(codecStringTree.ast)));
   const localPath = typeof path === "string" ? [path] : path ?? [];
-  return make26((provider, pathPrefix) => {
+  return make29((provider, pathPrefix) => {
     const fullPath = [...pathPrefix, ...localPath];
     return loadCursor(provider, fullPath).pipe(flatMapEager2((cursor) => decodeCursor(cursor).pipe(mapEager2(succeed2), catchEager2((issue) => {
       const error = new ConfigError(new SchemaError(fullPath.length > 0 ? new Pointer(fullPath, issue) : issue));
@@ -12512,17 +13341,17 @@ var log = (...args) => consoleWith((console) => sync(() => {
 // node_modules/effect/dist/Logger.js
 var LogToStderr2 = LogToStderr;
 // node_modules/effect/dist/cli/CliError.js
-var TypeId27 = "~effect/cli/CliError";
-var isCliError = (u) => hasProperty(u, TypeId27);
+var TypeId30 = "~effect/cli/CliError";
+var isCliError = (u) => hasProperty(u, TypeId30);
 var userMessage = "~effect/cli/CliError/userMessage";
 var getUserMessage = (error) => (userMessage in error) && typeof error[userMessage] === "string" ? error[userMessage] : undefined;
 
-class UnrecognizedOption extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/UnrecognizedOption`)("UnrecognizedOption", {
+class UnrecognizedOption extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/UnrecognizedOption`)("UnrecognizedOption", {
   option: String5,
   command: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String5)),
   suggestions: /* @__PURE__ */ ArraySchema(String5)
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   get message() {
     const suggestionText = this.suggestions.length > 0 ? `
 
@@ -12534,52 +13363,52 @@ class UnrecognizedOption extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/Unre
   }
 }
 
-class DuplicateOption extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/DuplicateOption`)("DuplicateOption", {
+class DuplicateOption extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/DuplicateOption`)("DuplicateOption", {
   option: String5,
   parentCommand: String5,
   childCommand: String5
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   get message() {
     return `Duplicate flag name "${this.option}" in parent command "${this.parentCommand}" and subcommand "${this.childCommand}". ` + `Parent will always claim this flag (Mode A semantics). Consider renaming one of them to avoid confusion.`;
   }
 }
 
-class MissingOption extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/MissingOption`)("MissingOption", {
+class MissingOption extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/MissingOption`)("MissingOption", {
   option: String5
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   get message() {
     return `Missing required flag: --${this.option}`;
   }
 }
 
-class MissingArgument extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/MissingArgument`)("MissingArgument", {
+class MissingArgument extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/MissingArgument`)("MissingArgument", {
   argument: String5
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   get message() {
     return `Missing required argument: ${this.argument}`;
   }
 }
 
-class UnexpectedArgument extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/UnexpectedArgument`)("UnexpectedArgument", {
+class UnexpectedArgument extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/UnexpectedArgument`)("UnexpectedArgument", {
   arguments: /* @__PURE__ */ ArraySchema(String5)
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   get message() {
     const label = this.arguments.length === 1 ? "argument" : "arguments";
     return `Unexpected positional ${label}: ${this.arguments.map((value) => JSON.stringify(value)).join(", ")}`;
   }
 }
 
-class InvalidValue2 extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/InvalidValue`)("InvalidValue", {
+class InvalidValue2 extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/InvalidValue`)("InvalidValue", {
   option: String5,
   value: String5,
   expected: String5,
   kind: /* @__PURE__ */ Union2([/* @__PURE__ */ Literal2("flag"), /* @__PURE__ */ Literal2("argument")])
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   get message() {
     const expectation = this.expected.startsWith("Expected ") || this.expected.startsWith("Expected:") ? this.expected : `Expected: ${this.expected}`;
     if (this.kind === "argument") {
@@ -12592,12 +13421,12 @@ class InvalidValue2 extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/InvalidVa
   }
 }
 
-class UnknownSubcommand extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/UnknownSubcommand`)("UnknownSubcommand", {
+class UnknownSubcommand extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/UnknownSubcommand`)("UnknownSubcommand", {
   subcommand: String5,
   parent: /* @__PURE__ */ optional2(/* @__PURE__ */ ArraySchema(String5)),
   suggestions: /* @__PURE__ */ ArraySchema(String5)
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   get message() {
     const suggestionText = this.suggestions.length > 0 ? `
 
@@ -12608,17 +13437,17 @@ class UnknownSubcommand extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/Unkno
   }
 }
 
-class ValidationError extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/ValidationError`)("ValidationError", {
+class ValidationError extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/ValidationError`)("ValidationError", {
   message: String5
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
 }
 
-class UserError extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/UserError`)("UserError", {
+class UserError extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/UserError`)("UserError", {
   cause: /* @__PURE__ */ Defect(),
   userMessage: /* @__PURE__ */ optionalKey2(String5)
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   [errorReported] = true;
   get message() {
     if (this.userMessage)
@@ -12635,11 +13464,11 @@ class UserError extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/UserError`)("
 }
 var NonShowHelpErrors = /* @__PURE__ */ Union2([UnrecognizedOption, DuplicateOption, MissingOption, MissingArgument, UnexpectedArgument, InvalidValue2, UnknownSubcommand, ValidationError, UserError]);
 
-class ShowHelp extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/ShowHelp`)("ShowHelp", {
+class ShowHelp extends (/* @__PURE__ */ TaggedError3(`${TypeId30}/ShowHelp`)("ShowHelp", {
   commandPath: /* @__PURE__ */ ArraySchema(String5),
   errors: /* @__PURE__ */ ArraySchema(NonShowHelpErrors)
 })) {
-  [TypeId27] = TypeId27;
+  [TypeId30] = TypeId30;
   [errorExitCode] = this.errors.length ? 1 : 0;
   [errorReported] = false;
   get message() {
@@ -12648,16 +13477,16 @@ class ShowHelp extends (/* @__PURE__ */ TaggedError3(`${TypeId27}/ShowHelp`)("Sh
 }
 
 // node_modules/effect/dist/cli/Primitive.js
-var TypeId28 = "~effect/cli/Primitive";
-var Proto6 = {
-  [TypeId28]: {
+var TypeId31 = "~effect/cli/Primitive";
+var Proto9 = {
+  [TypeId31]: {
     _A: identity
   }
 };
 var isTrueLiteral = /* @__PURE__ */ is2(TrueLiterals);
 var isFalseLiteral = /* @__PURE__ */ is2(FalseLiterals);
 var isBoolean2 = (p) => p._tag === "Boolean";
-var makePrimitive2 = (tag, parse) => Object.assign(Object.create(Proto6), {
+var makePrimitive2 = (tag, parse) => Object.assign(Object.create(Proto9), {
   _tag: tag,
   parse
 });
@@ -12785,7 +13614,7 @@ var eraseLines = (rows) => {
 };
 
 // node_modules/effect/dist/cli/Prompt.js
-var TypeId29 = "~effect/cli/Prompt";
+var TypeId32 = "~effect/cli/Prompt";
 var defaultTheme = {
   prefix: "?",
   arrowUp: "\u2191",
@@ -12822,7 +13651,7 @@ var makeTheme = (options) => ({
 var Theme = /* @__PURE__ */ Reference("effect/cli/Prompt/Theme", {
   defaultValue: makeTheme
 });
-var getTheme = (options) => map5(Theme, (theme) => ({
+var getTheme = (options) => map6(Theme, (theme) => ({
   ...theme,
   ...options.theme
 }));
@@ -12874,7 +13703,7 @@ var Custom = (initialState, ...args) => {
   op.events = events;
   return op;
 };
-var Date4 = (options) => {
+var Date5 = (options) => {
   const opts = {
     initial: new globalThis.Date,
     dateMask: "YYYY-MM-DD HH:mm:ss",
@@ -12968,8 +13797,8 @@ var Int2 = (options) => {
     clear: handleNumberClear(opts)
   });
 };
-var map8 = /* @__PURE__ */ dual(2, (self, f) => flatMap5(self, (a) => succeed9(f(a))));
-var Password = (options) => basePrompt(options, "password").pipe(map8(make16));
+var map9 = /* @__PURE__ */ dual(2, (self, f) => flatMap5(self, (a) => succeed9(f(a))));
+var Password = (options) => basePrompt(options, "password").pipe(map9(make17));
 var run3 = /* @__PURE__ */ fnUntraced2(function* (self) {
   const terminal = yield* Terminal;
   const input = yield* cached2(terminal.readInput);
@@ -13031,7 +13860,7 @@ var proto = {
       return run3(this);
     }
   }),
-  [TypeId29]: {
+  [TypeId32]: {
     _Output: (_) => _
   }
 };
@@ -13060,11 +13889,11 @@ var runLoop = /* @__PURE__ */ fnUntraced2(function* (loop, terminal, input) {
     yield* orDie2(terminal.display(clear + msg));
     clear = "";
     if (loop.events) {
-      const takeInput = take2(input).pipe(map5((input) => ({
+      const takeInput = take2(input).pipe(map6((input) => ({
         _tag: "Input",
         input
       })));
-      const result = yield* raceFirst2(takeInput, take2(loop.events).pipe(map5((value) => ({
+      const result = yield* raceFirst2(takeInput, take2(loop.events).pipe(map6((value) => ({
         _tag: "Event",
         value
       }))));
@@ -13104,7 +13933,7 @@ var eraseText = (text, columns) => {
 };
 var lines = (prompt, columns) => {
   const lines = prompt.split(NEWLINE_REGEXP);
-  return columns === 0 ? lines.length : pipe(map2(lines, (line) => Math.ceil(line.length / columns)), reduce(0, (left, right) => left + right));
+  return columns === 0 ? lines.length : pipe(map3(lines, (line) => Math.ceil(line.length / columns)), reduce(0, (left, right) => left + right));
 };
 var clearOutputWithError = (outputText, columns, errorText) => {
   if (errorText !== undefined && errorText.length > 0) {
@@ -13205,7 +14034,7 @@ var renderDateError = (state, pointer, theme) => {
     const errorLines = state.error.value.split(NEWLINE_REGEXP);
     if (isReadonlyArrayNonEmpty(errorLines)) {
       const prefix = annotateSymbol(theme, pointer, theme.errorColor);
-      const lines = map2(errorLines, (str) => annotateErrorLine(theme, str));
+      const lines = map3(errorLines, (str) => annotateErrorLine(theme, str));
       return cursorSavePosition + `
 ` + separateSymbol(prefix, lines.join(`
 `)) + cursorRestorePosition;
@@ -13648,7 +14477,7 @@ var renderPrompt = (confirm, message, leadingSymbol, trailingSymbol, theme, opti
   return match3(message.split(NEWLINE_REGEXP), {
     onEmpty: () => renderLine(""),
     onNonEmpty: (promptLines) => {
-      const lines = options?.plain === true ? promptLines : map2(promptLines, (line) => annotate2(theme.colors, line, bold));
+      const lines = options?.plain === true ? promptLines : map3(promptLines, (line) => annotate2(theme.colors, line, bold));
       return renderLine(lines.join(`
 `));
     }
@@ -13695,7 +14524,7 @@ var renderNumberError = (state, pointer, theme, renderOptions) => {
 `));
         }
         const prefix = annotateSymbol(theme, pointer, theme.errorColor);
-        const lines = map2(errorLines, (str) => annotateErrorLine(theme, str));
+        const lines = map3(errorLines, (str) => annotateErrorLine(theme, str));
         return cursorSavePosition + `
 ` + separateSymbol(prefix, lines.join(`
 `)) + cursorRestorePosition;
@@ -14124,7 +14953,7 @@ var renderTextError = (nextState, pointer, theme, renderOptions) => {
 `));
         }
         const prefix = annotateSymbol(theme, pointer, theme.errorColor);
-        const lines = map2(errorLines, (str) => annotateErrorLine(theme, str));
+        const lines = map3(errorLines, (str) => annotateErrorLine(theme, str));
         return cursorSavePosition + `
 ` + separateSymbol(prefix, lines.join(`
 `)) + cursorRestorePosition;
@@ -14473,18 +15302,18 @@ var fromProcess = () => {
 };
 
 // node_modules/effect/dist/cli/Param.js
-var TypeId30 = "~effect/cli/Param";
+var TypeId33 = "~effect/cli/Param";
 var argumentKind = "argument";
 var flagKind = "flag";
-var Proto7 = {
-  [TypeId30]: {
+var Proto10 = {
+  [TypeId33]: {
     _A: identity
   },
   pipe() {
     return pipeArguments(this, arguments);
   }
 };
-var isParam = (u) => hasProperty(u, TypeId30);
+var isParam = (u) => hasProperty(u, TypeId33);
 var isFlagParam = (single) => single.kind === "flag";
 var makeSingle2 = (params) => {
   const parse = (args) => params.kind === argumentKind ? parsePositional(params.name, params.primitiveType, args) : parseFlag(params.name, params.primitiveType, args);
@@ -14495,7 +15324,7 @@ var makeSingle2 = (params) => {
     aliases: params.aliases ?? [],
     hidden: params.hidden ?? false,
     parse
-  }, Proto7);
+  }, Proto10);
 };
 var String9 = (kind, name) => makeSingle2({
   name,
@@ -14525,9 +15354,9 @@ var withDescription = /* @__PURE__ */ dual(2, (self, description) => {
     description: some2(description)
   }));
 });
-var map9 = /* @__PURE__ */ dual(2, (self, f) => {
-  const parse = (args) => map5(self.parse(args), ([operands, value]) => [operands, f(value)]);
-  return Object.assign(Object.create(Proto7), {
+var map10 = /* @__PURE__ */ dual(2, (self, f) => {
+  const parse = (args) => map6(self.parse(args), ([operands, value]) => [operands, f(value)]);
+  return Object.assign(Object.create(Proto10), {
     _tag: "Map",
     kind: self.kind,
     param: self,
@@ -14537,7 +15366,7 @@ var map9 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var transform3 = (self, f, alternatives = []) => {
   const alternativeParsers = alternatives.map((alternative) => () => alternative().parse);
-  return Object.assign(Object.create(Proto7), {
+  return Object.assign(Object.create(Proto10), {
     _tag: "Transform",
     kind: self.kind,
     param: self,
@@ -14546,13 +15375,13 @@ var transform3 = (self, f, alternatives = []) => {
     parse: f(self.parse, alternativeParsers)
   });
 };
-var mapEffect2 = /* @__PURE__ */ dual(2, (self, f) => transform3(self, (parse) => (args) => flatMap3(parse(args), ([leftover, a]) => f(a).pipe(map5((b) => [leftover, b])))));
+var mapEffect2 = /* @__PURE__ */ dual(2, (self, f) => transform3(self, (parse) => (args) => flatMap3(parse(args), ([leftover, a]) => f(a).pipe(map6((b) => [leftover, b])))));
 var optional3 = (param) => {
-  const parse = (args) => param.parse(args).pipe(map5(([leftover, value]) => [leftover, some2(value)]), catchTags2({
+  const parse = (args) => param.parse(args).pipe(map6(([leftover, value]) => [leftover, some2(value)]), catchTags2({
     MissingOption: () => succeed6([args.arguments, none2()]),
     MissingArgument: () => succeed6([args.arguments, none2()])
   }));
-  return Object.assign(Object.create(Proto7), {
+  return Object.assign(Object.create(Proto10), {
     _tag: "Optional",
     kind: param.kind,
     param,
@@ -14561,7 +15390,7 @@ var optional3 = (param) => {
 };
 var withDefault4 = /* @__PURE__ */ dual(2, (self, defaultValue) => {
   if (!isEffect2(defaultValue)) {
-    return map9(optional3(self), getOrElse(() => defaultValue));
+    return map10(optional3(self), getOrElse(() => defaultValue));
   }
   return mapEffect2(optional3(self), match({
     onNone: () => defaultValue,
@@ -14577,7 +15406,7 @@ var variadic = (self, options) => {
       return parseOptionVariadic(self, single, args, options);
     }
   };
-  return Object.assign(Object.create(Proto7), {
+  return Object.assign(Object.create(Proto10), {
     _tag: "Variadic",
     kind: self.kind,
     param: self,
@@ -14708,7 +15537,7 @@ var matchParam = (param, patterns) => {
 var transformSingle = (param, f) => {
   return matchParam(param, {
     Single: (single) => f(single),
-    Map: (mapped) => map9(transformSingle(mapped.param, f), mapped.f),
+    Map: (mapped) => map10(transformSingle(mapped.param, f), mapped.f),
     Transform: (mapped) => transform3(transformSingle(mapped.param, f), mapped.f, mapped.alternatives.map((alternative) => () => transformSingle(alternative(), f))),
     Optional: (p) => optional3(transformSingle(p.param, f)),
     Variadic: (p) => variadic(transformSingle(p.param, f), {
@@ -15072,9 +15901,9 @@ var reconstructTree = (tree, results) => {
 };
 
 // node_modules/effect/dist/cli/internal/command.js
-var TypeId31 = "~effect/cli/Command";
+var TypeId34 = "~effect/cli/Command";
 var toImpl = (self) => self;
-var Proto8 = {
+var Proto11 = {
   .../* @__PURE__ */ Prototype2({
     label: "Command",
     evaluate() {
@@ -15085,7 +15914,7 @@ var Proto8 = {
 var makeCommand = (options) => {
   const config = options.config;
   const contextConfig = options.contextConfig ?? emptyConfig;
-  const service = options.service ?? Service(`${TypeId31}/${options.name}`);
+  const service = options.service ?? Service(`${TypeId34}/${options.name}`);
   const annotations = options.annotations ?? empty();
   const globalFlags = options.globalFlags ?? [];
   const subcommands = options.subcommands ?? [];
@@ -15139,7 +15968,7 @@ var makeCommand = (options) => {
         continue;
       subcommandDocs.push({
         group: group.group,
-        commands: map2(visible, (subcommand) => ({
+        commands: map3(visible, (subcommand) => ({
           name: subcommand.name,
           alias: subcommand.alias,
           shortDescription: subcommand.shortDescription,
@@ -15164,8 +15993,8 @@ var makeCommand = (options) => {
       }
     };
   };
-  return Object.assign(Object.create(Proto8), {
-    [TypeId31]: TypeId31,
+  return Object.assign(Object.create(Proto11), {
+    [TypeId34]: TypeId34,
     name: options.name,
     examples: resolveExamples([options.name]),
     resolveExamples,
@@ -17344,7 +18173,7 @@ var promptSingle = (single) => {
   const message = renderParamMessage(single);
   switch (single.primitiveType._tag) {
     case "Boolean":
-      return map5(run3(Confirm({
+      return map6(run3(Confirm({
         message,
         label: {
           confirm: "true",
@@ -17357,7 +18186,7 @@ var promptSingle = (single) => {
       })), (value) => commandLineArg(String(value)));
     case "Choice": {
       const choices = getChoiceKeys(single.primitiveType) ?? [];
-      return map5(run3(Select({
+      return map6(run3(Select({
         message,
         choices: choices.map((choice) => ({
           title: choice,
@@ -17366,23 +18195,23 @@ var promptSingle = (single) => {
       })), commandLineArg);
     }
     case "Date":
-      return map5(run3(Date4({
+      return map6(run3(Date5({
         message
       })), (date) => commandLineArg(date.toISOString()));
     case "Finite":
-      return map5(run3(Number7({
+      return map6(run3(Number7({
         message
       })), (value) => commandLineArg(String(value)));
     case "Int":
-      return map5(run3(Int2({
+      return map6(run3(Int2({
         message
       })), (value) => commandLineArg(String(value)));
     case "Redacted":
-      return map5(run3(Password({
+      return map6(run3(Password({
         message
       })), (value) => commandLineArg(value2(value), "<redacted>"));
     default:
-      return map5(run3(String8({
+      return map6(run3(String8({
         message
       })), commandLineArg);
   }
@@ -17443,8 +18272,8 @@ var wrapCommand = (commandLine) => {
 var formatShellArg = (arg) => /^[A-Za-z0-9_./:@%+=,-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'"'"'`)}'`;
 
 // node_modules/effect/dist/cli/Command.js
-var isCommand = (u) => hasProperty(u, TypeId31);
-var make27 = (name, config, handler) => {
+var isCommand = (u) => hasProperty(u, TypeId34);
+var make30 = (name, config, handler) => {
   const parsedConfig = parseConfig(config ?? {});
   return makeCommand({
     name,
@@ -17727,7 +18556,7 @@ var runWith2 = (command, config) => {
     }
     const services = match(logLevel, {
       onNone: () => empty(),
-      onSome: (level) => make2(MinimumLogLevel2, level)
+      onSome: (level) => make3(MinimumLogLevel2, level)
     });
     yield* provideContext2(program, services);
   }, catchFilter2((error) => isCliError(error) && error._tag === "ShowHelp" ? succeed2(error) : fail2(error), (error) => andThen2(showHelp(command, error, config.renderErrors !== false), fail7(error))), catchFilter2((error) => {
@@ -17744,39 +18573,912 @@ var runWith2 = (command, config) => {
   }) => andThen2(showUserError(error, userMessage), fail7(error))), catchFilter2((e) => isQuitError(e) ? succeed2(e) : fail2(e), (_) => interrupt2));
 };
 // package.json
-var version = "0.0.2";
-// src/process.ts
-var run6 = fn2("Process.run")(function* run(command) {
-  const child = yield* command;
-  const output = yield* child.stdout.pipe(decodeText2(), mkString);
-  const code = yield* child.exitCode;
-  if (code !== 0) {
-    return yield* new UserError({
-      cause: `${command.command} exited with status ${code}.`
+var version = "0.0.4";
+// node_modules/effect/dist/http/HttpBody.js
+var TypeId35 = "~effect/http/HttpBody";
+var HttpBodyErrorTypeId = "~effect/http/HttpBody/HttpBodyError";
+
+class HttpBodyError extends (/* @__PURE__ */ TaggedError2("HttpBodyError")) {
+  [HttpBodyErrorTypeId] = HttpBodyErrorTypeId;
+}
+class Proto12 {
+  [TypeId35];
+  constructor() {
+    this[TypeId35] = TypeId35;
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  toString() {
+    return format(this, {
+      ignoreToString: true
     });
   }
-  return output;
-}, scoped2);
-var convex = (args, env, input) => run6(make17("bunx", ["--no-install", "convex", ...args], {
-  env,
-  extendEnv: true,
-  stderr: "inherit",
-  stdin: input === undefined ? "inherit" : make12(new TextEncoder().encode(input)),
-  stdout: "inherit"
+}
+
+class Empty2 extends Proto12 {
+  _tag = "Empty";
+  toJSON() {
+    return {
+      _id: "effect/HttpBody",
+      _tag: "Empty"
+    };
+  }
+}
+var empty7 = /* @__PURE__ */ new Empty2;
+class Uint8Array3 extends Proto12 {
+  _tag = "Uint8Array";
+  contentType;
+  contentLength;
+  text;
+  _body;
+  constructor(body, contentType, contentLength, text) {
+    super();
+    this._body = body;
+    this.text = text;
+    this.contentType = contentType;
+    this.contentLength = contentLength;
+  }
+  get body() {
+    return this._body ??= encodeText(this.text);
+  }
+  toJSON() {
+    const toString = this.contentType.startsWith("text/") || this.contentType.endsWith("json");
+    return {
+      _id: "effect/HttpBody",
+      _tag: "Uint8Array",
+      body: toString ? new TextDecoder().decode(this.body) : `Uint8Array(${this.body.length})`,
+      contentType: this.contentType,
+      contentLength: this.contentLength
+    };
+  }
+}
+var encoder2 = /* @__PURE__ */ new TextEncoder;
+var buffer2 = globalThis.Buffer;
+var encodeText = buffer2 !== undefined ? (body) => buffer2.from(body, "utf8") : (body) => encoder2.encode(body);
+var text = (body, contentType) => {
+  if (typeof body !== "string") {
+    body = body === undefined ? "" : String(body);
+  }
+  if (buffer2 !== undefined) {
+    return new Uint8Array3(undefined, contentType ?? "text/plain", buffer2.byteLength(body, "utf8"), body);
+  }
+  const bytes = encoder2.encode(body);
+  return new Uint8Array3(bytes, contentType ?? "text/plain", bytes.length, body);
+};
+var json = (body, contentType) => try_3({
+  try: () => text(JSON.stringify(body), contentType ?? "application/json"),
+  catch: (cause) => new HttpBodyError({
+    reason: {
+      _tag: "JsonError"
+    },
+    cause
+  })
+});
+
+// node_modules/effect/dist/http/HttpClientError.js
+var TypeId36 = "~effect/http/HttpClientError";
+class HttpClientError extends (/* @__PURE__ */ TaggedError2("HttpClientError")) {
+  constructor(props) {
+    if ("cause" in props.reason) {
+      super({
+        ...props,
+        cause: props.reason.cause
+      });
+    } else {
+      super(props);
+    }
+  }
+  [TypeId36] = TypeId36;
+  get request() {
+    return this.reason.request;
+  }
+  get response() {
+    return "response" in this.reason ? this.reason.response : undefined;
+  }
+  get message() {
+    return this.reason.message;
+  }
+}
+var formatReason = (tag) => tag.endsWith("Error") ? tag.slice(0, -5) : tag;
+var formatMessage = (reason, description, info) => description ? `${reason}: ${description} (${info})` : `${reason} error (${info})`;
+var formatMethodAndUrl = (request) => `${request.method} ${redactUrl(request.url)}`;
+var reasonToJSON = (reason, json) => ({
+  ...json,
+  request: {
+    _id: "HttpClientRequest",
+    method: reason.request.method,
+    url: redactUrl(reason.request.url)
+  },
+  ..."response" in reason ? {
+    response: {
+      _id: "HttpClientResponse",
+      status: reason.response.status
+    }
+  } : undefined
+});
+
+class TransportError extends (/* @__PURE__ */ TaggedError2("TransportError")) {
+  get methodAndUrl() {
+    return formatMethodAndUrl(this.request);
+  }
+  get message() {
+    return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);
+  }
+  toJSON() {
+    return reasonToJSON(this, super.toJSON());
+  }
+}
+
+class EncodeError extends (/* @__PURE__ */ TaggedError2("EncodeError")) {
+  get methodAndUrl() {
+    return formatMethodAndUrl(this.request);
+  }
+  get message() {
+    return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);
+  }
+  toJSON() {
+    return reasonToJSON(this, super.toJSON());
+  }
+}
+
+class InvalidUrlError extends (/* @__PURE__ */ TaggedError2("InvalidUrlError")) {
+  get methodAndUrl() {
+    return formatMethodAndUrl(this.request);
+  }
+  get message() {
+    return formatMessage(formatReason(this._tag), this.description, this.methodAndUrl);
+  }
+  toJSON() {
+    return reasonToJSON(this, super.toJSON());
+  }
+}
+
+class StatusCodeError extends (/* @__PURE__ */ TaggedError2("StatusCodeError")) {
+  get methodAndUrl() {
+    return formatMethodAndUrl(this.request);
+  }
+  get message() {
+    const info = `${this.response.status} ${this.methodAndUrl}`;
+    return formatMessage(formatReason(this._tag), this.description, info);
+  }
+  toJSON() {
+    return reasonToJSON(this, super.toJSON());
+  }
+}
+
+class DecodeError extends (/* @__PURE__ */ TaggedError2("DecodeError")) {
+  get methodAndUrl() {
+    return formatMethodAndUrl(this.request);
+  }
+  get message() {
+    const info = `${this.response.status} ${this.methodAndUrl}`;
+    return formatMessage(formatReason(this._tag), this.description, info);
+  }
+  toJSON() {
+    return reasonToJSON(this, super.toJSON());
+  }
+}
+
+class EmptyBodyError extends (/* @__PURE__ */ TaggedError2("EmptyBodyError")) {
+  get methodAndUrl() {
+    return formatMethodAndUrl(this.request);
+  }
+  get message() {
+    const info = `${this.response.status} ${this.methodAndUrl}`;
+    return formatMessage(formatReason(this._tag), this.description, info);
+  }
+  toJSON() {
+    return reasonToJSON(this, super.toJSON());
+  }
+}
+
+// node_modules/effect/dist/http/HttpMethod.js
+var allShort = [["GET", "get"], ["POST", "post"], ["PUT", "put"], ["DELETE", "del"], ["PATCH", "patch"], ["HEAD", "head"], ["OPTIONS", "options"], ["TRACE", "trace"], ["QUERY", "query"]];
+
+// node_modules/effect/dist/http/internal/httpBody.js
+var updateHeaders = (headers, body) => {
+  if (body._tag === "Empty" || body._tag === "FormData") {
+    return remove3(remove3(headers, "content-type"), "content-length");
+  }
+  headers = body.contentType === undefined ? remove3(headers, "content-type") : set2(headers, "content-type", body.contentType);
+  return updateContentLength(headers, body);
+};
+var updateContentLength = (headers, body) => {
+  const contentLength = body._tag === "Empty" || body._tag === "FormData" ? undefined : body.contentLength;
+  return contentLength === undefined ? remove3(headers, "content-length") : set2(headers, "content-length", contentLength.toString());
+};
+
+// node_modules/effect/dist/http/Url.js
+class UrlError extends (/* @__PURE__ */ TaggedError2("UrlError")) {
+}
+var make31 = (url, params, hash) => try_({
+  try: () => {
+    const urlInstance = new URL(url, baseUrl());
+    for (let i = 0;i < params.params.length; i++) {
+      const [key, value] = params.params[i];
+      if (value !== undefined) {
+        urlInstance.searchParams.append(key, unwrap6(value));
+      }
+    }
+    if (hash !== undefined) {
+      urlInstance.hash = hash;
+    }
+    return urlInstance;
+  },
+  catch: (cause) => new UrlError({
+    cause
+  })
+});
+var baseUrl = () => {
+  if ("location" in globalThis && globalThis.location !== undefined && globalThis.location.origin !== undefined && globalThis.location.pathname !== undefined) {
+    const base = location.origin + location.pathname;
+    try {
+      return new URL(base).href;
+    } catch {
+      return;
+    }
+  }
+  return;
+};
+
+// node_modules/effect/dist/http/HttpClientRequest.js
+var TypeId37 = "~effect/http/HttpClientRequest";
+var Proto13 = {
+  [TypeId37]: TypeId37,
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "HttpClientRequest",
+      method: this.method,
+      url: redactUrl(this.url),
+      urlParams: this.urlParams,
+      hash: this.hash,
+      headers: redact(this.headers),
+      body: this.body.toJSON()
+    };
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+function makeWith(method, url, urlParams, hash, headers, body) {
+  const self = Object.create(Proto13);
+  self.method = method;
+  self.url = url;
+  self.urlParams = urlParams;
+  self.hash = hash;
+  self.headers = headers;
+  self.body = body;
+  return self;
+}
+var empty8 = /* @__PURE__ */ makeWith("GET", "", empty6, /* @__PURE__ */ none2(), empty5, empty7);
+var make32 = (method) => (url, options) => modify(empty8, {
+  method,
+  url,
+  ...options ?? undefined
+});
+var get4 = /* @__PURE__ */ make32("GET");
+var post = /* @__PURE__ */ make32("POST");
+var modify = /* @__PURE__ */ dual(2, (self, options) => {
+  let result = self;
+  if (options.method) {
+    result = setMethod(result, options.method);
+  }
+  if (options.url) {
+    result = setUrl(result, options.url);
+  }
+  if (options.headers) {
+    result = setHeaders(result, options.headers);
+  }
+  if (options.urlParams) {
+    result = setUrlParams(result, options.urlParams);
+  }
+  if (options.hash) {
+    result = setHash(result, options.hash);
+  }
+  if (options.body) {
+    result = setBody(result, options.body);
+  }
+  if (options.accept) {
+    result = accept(result, options.accept);
+  }
+  if (options.acceptJson) {
+    result = acceptJson(result);
+  }
+  return result;
+});
+var setMethod = /* @__PURE__ */ dual(2, (self, method) => makeWith(method, self.url, self.urlParams, self.hash, self.headers, self.body));
+var setHeader = /* @__PURE__ */ dual(3, (self, key, value) => makeWith(self.method, self.url, self.urlParams, self.hash, set2(self.headers, key, value), self.body));
+var setHeaders = /* @__PURE__ */ dual(2, (self, input) => makeWith(self.method, self.url, self.urlParams, self.hash, setAll(self.headers, input), self.body));
+var accept = /* @__PURE__ */ dual(2, (self, mediaType) => setHeader(self, "Accept", mediaType));
+var acceptJson = /* @__PURE__ */ accept("application/json");
+var setUrl = /* @__PURE__ */ dual(2, (self, url) => {
+  if (typeof url === "string") {
+    return makeWith(self.method, url, self.urlParams, self.hash, self.headers, self.body);
+  }
+  const clone = new URL(url.toString());
+  const urlParams = fromInput2(clone.searchParams);
+  const hash = fromNullishOr(clone.hash === "" ? undefined : clone.hash.slice(1));
+  clone.search = "";
+  clone.hash = "";
+  return makeWith(self.method, clone.toString(), urlParams, hash, self.headers, self.body);
+});
+var setUrlParams = /* @__PURE__ */ dual(2, (self, input) => makeWith(self.method, self.url, setAll2(self.urlParams, input), self.hash, self.headers, self.body));
+var setHash = /* @__PURE__ */ dual(2, (self, hash) => makeWith(self.method, self.url, self.urlParams, some2(hash), self.headers, self.body));
+var setBody = /* @__PURE__ */ dual(2, (self, body) => {
+  return makeWith(self.method, self.url, self.urlParams, self.hash, updateHeaders(self.headers, body), body);
+});
+var bodyJson = /* @__PURE__ */ dual(2, (self, body) => map6(json(body), (body) => setBody(self, body)));
+function toUrl(self) {
+  const r = make31(self.url, self.urlParams, getOrUndefined(self.hash));
+  if (isSuccess2(r)) {
+    return some2(r.success);
+  }
+  return none2();
+}
+
+// node_modules/effect/dist/http/HttpIncomingMessage.js
+var TypeId38 = "~effect/http/HttpIncomingMessage";
+var inspect = (self, that) => {
+  return {
+    ...that,
+    headers: redact(self.headers),
+    remoteAddress: self.remoteAddress
+  };
+};
+
+// node_modules/effect/dist/http/internal/webResponse.js
+var WebSourceSymbol = "~effect/http/HttpClientResponse/WebSource";
+var getWebSource = (self) => self[WebSourceSymbol]?.();
+
+// node_modules/effect/dist/http/HttpClientResponse.js
+var TypeId39 = "~effect/http/HttpClientResponse";
+var fromWeb = (request, source) => new WebHttpClientResponse(request, source);
+var filterStatusOk = (self) => self.status >= 200 && self.status < 300 ? succeed6(self) : fail7(new HttpClientError({
+  reason: new StatusCodeError({
+    response: self,
+    request: self.request,
+    description: "non 2xx status code"
+  })
 }));
 
-// src/dotenv.ts
-var dotenvx = fn2("Dotenvx.run")(function* dotenvx(args, capture) {
-  const path = yield* Path;
-  const bin = yield* path.fromFileUrl(new URL("src/cli/dotenvx.js", import.meta.resolve("@dotenvx/dotenvx/package.json")));
-  return yield* run6(make17("bun", [bin, ...args], {
-    stderr: capture ? "ignore" : "inherit",
-    stdin: "inherit",
-    stdout: capture ? "pipe" : "inherit"
-  }));
+class WebHttpClientResponse extends Class2 {
+  [TypeId38];
+  [TypeId39];
+  request;
+  source;
+  constructor(request, source) {
+    super();
+    this.request = request;
+    this.source = source;
+    this[TypeId38] = TypeId38;
+    this[TypeId39] = TypeId39;
+  }
+  toJSON() {
+    return inspect(this, {
+      _id: "HttpClientResponse",
+      request: this.request.toJSON(),
+      status: this.status
+    });
+  }
+  get status() {
+    return this.source.status;
+  }
+  get url() {
+    if (this.source.url)
+      return this.source.url.split("#")[0];
+    const url = toUrl(this.request);
+    if (isNone2(url))
+      return "";
+    url.value.hash = "";
+    return url.value.href;
+  }
+  get headers() {
+    return fromInput(this.source.headers);
+  }
+  cachedCookies;
+  get cookies() {
+    if (this.cachedCookies) {
+      return this.cachedCookies;
+    }
+    return this.cachedCookies = fromSetCookie(this.source.headers.getSetCookie?.() ?? []);
+  }
+  get remoteAddress() {
+    return none2();
+  }
+  [WebSourceSymbol]() {
+    return this.source;
+  }
+  get stream() {
+    return this.source.body ? fromReadableStream2({
+      evaluate: () => this.source.body,
+      onError: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }) : fail9(new HttpClientError({
+      reason: new EmptyBodyError({
+        request: this.request,
+        response: this,
+        description: "can not create stream from empty body"
+      })
+    }));
+  }
+  get json() {
+    return flatMap3(this.text, (text) => try_3({
+      try: () => text === "" ? null : JSON.parse(text),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  textBody;
+  get text() {
+    return this.textBody ??= map6(this.arrayBuffer, (_) => new TextDecoder().decode(_));
+  }
+  get urlParamsBody() {
+    return flatMap3(this.arrayBuffer, (bytes) => try_3({
+      try: () => fromInput2(fromBody(bytes)),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }));
+  }
+  formDataBody;
+  get formData() {
+    return this.formDataBody ??= tryPromise2({
+      try: () => this.source.formData(),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }).pipe(cached2, runSync2);
+  }
+  arrayBufferBody;
+  get arrayBuffer() {
+    if (this.arrayBufferBody) {
+      return this.arrayBufferBody;
+    }
+    this.arrayBufferBody = tryPromise2({
+      try: () => this.source.arrayBuffer(),
+      catch: (cause) => new HttpClientError({
+        reason: new DecodeError({
+          request: this.request,
+          response: this,
+          cause
+        })
+      })
+    }).pipe(cached2, runSync2);
+    return this.arrayBufferBody;
+  }
+  get upgrade() {
+    return fail7(new HttpClientError({
+      reason: new StatusCodeError({
+        request: this.request,
+        response: this,
+        description: "fetch cannot hand over the connection of an HTTP upgrade"
+      })
+    }));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+// node_modules/effect/dist/http/HttpTraceContext.js
+var toHeaders = (span) => fromRecordUnsafe({
+  b3: `${span.traceId}-${span.spanId}-${span.sampled ? "1" : "0"}${match(span.parent, {
+    onNone: () => "",
+    onSome: (parent) => `-${parent.spanId}`
+  })}`,
+  traceparent: `00-${span.traceId.padStart(32, "0")}-${span.spanId}-${span.sampled ? "01" : "00"}`
 });
-var decrypt = (file) => dotenvx(["decrypt", "--stdout", "--no-armor", "--no-native", "-f", file], true);
 
+// node_modules/effect/dist/http/internal/tracing.js
+var defaultPorts = {
+  "http:": 80,
+  "https:": 443,
+  "ws:": 80,
+  "wss:": 443
+};
+var addUrlAttributes = (span, url, redactedNames) => {
+  const query = redactUrl(url.search, redactedNames).slice(1);
+  span.attribute("url.full", redactUrl(url.href, redactedNames));
+  span.attribute("url.path", url.pathname);
+  if (query !== "") {
+    span.attribute("url.query", query);
+  }
+  span.attribute("url.scheme", url.protocol.slice(0, -1));
+  if (url.hostname !== "") {
+    span.attribute("server.address", url.hostname.startsWith("[") ? url.hostname.slice(1, -1) : url.hostname);
+    const port = url.port === "" ? defaultPorts[url.protocol] : Number(url.port);
+    if (port !== undefined) {
+      span.attribute("server.port", port);
+    }
+  }
+};
+var redactedNames = (urlParams, redactedNames) => {
+  const keys = urlParams.params.filter(([, value]) => typeof value !== "string").map(([key]) => key);
+  return keys.length === 0 ? redactedNames : [...redactedNames, ...new URLSearchParams(keys.map((key) => [key, ""])).keys()];
+};
+var addHeaderAttributes = (span, phase, headers, filter, redactedNames) => {
+  for (const name in headers) {
+    if (!filter(name, phase))
+      continue;
+    span.attribute(`http.${phase}.header.${name}`, isRedactedName(name, redactedNames) ? "<redacted>" : headers[name]);
+  }
+};
+
+// node_modules/effect/dist/http/HttpClient.js
+var TypeId40 = "~effect/http/HttpClient";
+var HttpClient = /* @__PURE__ */ Service("effect/HttpClient");
+var transformResponse = /* @__PURE__ */ dual(2, (self, f) => makeWith2((request) => f(self.postprocess(request)), self.preprocess));
+var filterStatusOk2 = /* @__PURE__ */ transformResponse(/* @__PURE__ */ flatMap3(filterStatusOk));
+var makeWith2 = (postprocess, preprocess) => {
+  const self = Object.create(Proto14);
+  self.preprocess = preprocess;
+  self.postprocess = postprocess;
+  self.execute = function(request) {
+    return postprocess(preprocess(request));
+  };
+  return self;
+};
+var Proto14 = {
+  [TypeId40]: TypeId40,
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  ...BaseProto,
+  toJSON() {
+    return {
+      _id: "effect/HttpClient"
+    };
+  },
+  .../* @__PURE__ */ Object.fromEntries(/* @__PURE__ */ allShort.map(([fullMethod, method]) => [method, function(url, options) {
+    return this.execute(make32(fullMethod)(url, options));
+  }]))
+};
+var make33 = (f) => makeWith2((effect) => flatMap3(effect, (request) => withFiber2((fiber) => {
+  const scopedController = scopedRequests.get(request);
+  const controller = scopedController ?? new AbortController;
+  const urlResult = make31(request.url, request.urlParams, getOrUndefined(request.hash));
+  if (isFailure2(urlResult)) {
+    return fail7(new HttpClientError({
+      reason: new InvalidUrlError({
+        request,
+        cause: urlResult.failure
+      })
+    }));
+  }
+  const url = urlResult.success;
+  const tracerDisabled = fiber.getRef(DisablePropagation) || fiber.getRef(TracerDisabledWhen)(request);
+  if (tracerDisabled) {
+    const effect = f(request, url, controller.signal, fiber);
+    if (scopedController)
+      return map6(effect, (response) => trackResponse(response, controller, true));
+    return uninterruptibleMask2((restore) => matchCauseEffect2(restore(effect), {
+      onSuccess(response) {
+        return succeed6(trackResponse(response, controller, false));
+      },
+      onFailure(cause) {
+        if (hasInterrupts2(cause)) {
+          controller.abort();
+        }
+        return failCause3(cause);
+      }
+    }));
+  }
+  return useSpan2(fiber.getRef(SpanNameGenerator)(request), {
+    kind: "client"
+  }, (span) => {
+    span.attribute("http.request.method", request.method);
+    const redactedHeaderNames = fiber.getRef(CurrentRedactedNames);
+    addUrlAttributes(span, url, redactedNames(request.urlParams, fiber.getRef(CurrentRedactedNames2)));
+    const headerFilter = fiber.getRef(TracerHeaderFilter);
+    addHeaderAttributes(span, "request", request.headers, headerFilter, redactedHeaderNames);
+    request = fiber.getRef(TracerPropagationEnabled) ? setHeaders(request, toHeaders(span)) : request;
+    return uninterruptibleMask2((restore) => restore(f(request, url, controller.signal, fiber)).pipe(withParentSpan2(span, {
+      captureStackTrace: false
+    }), matchCauseEffect2({
+      onSuccess: (response) => {
+        span.attribute("http.response.status_code", response.status);
+        addHeaderAttributes(span, "response", response.headers, headerFilter, redactedHeaderNames);
+        if (response.status >= 400 && response.status < 600) {
+          span.attribute("error.type", String(response.status));
+          endSpanWithStatusError(fiber, span, request, response);
+        }
+        return succeed6(trackResponse(response, controller, scopedController !== undefined));
+      },
+      onFailure(cause) {
+        if (!scopedController && hasInterrupts2(cause)) {
+          controller.abort();
+        }
+        return failCause3(cause);
+      }
+    })));
+  });
+})), succeed6);
+var endSpanWithStatusError = (fiber, span, request, response) => {
+  const stackTraceLimit = getStackTraceLimit();
+  setStackTraceLimit(0);
+  let exit;
+  try {
+    exit = fail5(new HttpClientError({
+      reason: new StatusCodeError({
+        request,
+        response
+      })
+    }));
+  } finally {
+    setStackTraceLimit(stackTraceLimit);
+  }
+  span.end(fiber.getRef(TracerTimingEnabled2) ? fiber.getRef(Clock).currentTimeNanosUnsafe() : BigInt(0), exit);
+};
+var TracerDisabledWhen = /* @__PURE__ */ Reference("effect/http/HttpClient/TracerDisabledWhen", {
+  defaultValue: () => constFalse
+});
+var TracerHeaderFilter = /* @__PURE__ */ Reference("effect/http/HttpClient/TracerHeaderFilter", {
+  defaultValue: () => constFalse
+});
+var TracerPropagationEnabled = /* @__PURE__ */ Reference("effect/http/HttpClient/TracerPropagationEnabled", {
+  defaultValue: constTrue
+});
+var SpanNameGenerator = /* @__PURE__ */ Reference("effect/http/HttpClient/SpanNameGenerator", {
+  defaultValue: () => (request) => request.method
+});
+var layerMergedContext = (effect2) => effect(HttpClient)(contextWith2((context) => map6(effect2, (client) => transformResponse(client, updateContext2((input) => merge(context, input))))));
+var responseRegistry = /* @__PURE__ */ (() => {
+  if ("FinalizationRegistry" in globalThis && globalThis.FinalizationRegistry) {
+    const registry = /* @__PURE__ */ new FinalizationRegistry((controller) => {
+      try {
+        controller.abort();
+      } catch {}
+    });
+    return {
+      register(response, controller) {
+        registry.register(response, controller, response);
+      },
+      unregister(response) {
+        registry.unregister(response);
+      }
+    };
+  }
+  const timers = /* @__PURE__ */ new WeakMap;
+  return {
+    register(response, controller) {
+      timers.set(response, setTimeout(() => controller.abort(), 5000));
+    },
+    unregister(response) {
+      const timer = timers.get(response);
+      if (timer === undefined)
+        return;
+      clearTimeout(timer);
+      timers.delete(response);
+    }
+  };
+})();
+var scopedRequests = /* @__PURE__ */ new WeakMap;
+var responseControllers = /* @__PURE__ */ new WeakMap;
+var trackResponse = (response, controller, scoped) => {
+  if (!scoped) {
+    responseRegistry.register(response, controller);
+    response = new InterruptibleResponse(response, controller);
+  }
+  responseControllers.set(response, controller);
+  return response;
+};
+
+class InterruptibleResponse {
+  original;
+  controller;
+  constructor(original, controller) {
+    this.original = original;
+    this.controller = controller;
+  }
+  [TypeId39] = TypeId39;
+  [TypeId38] = TypeId38;
+  applyInterrupt(effect) {
+    return suspend2(() => {
+      responseRegistry.unregister(this.original);
+      return onInterrupt2(effect, () => sync2(() => {
+        this.controller.abort();
+      }));
+    });
+  }
+  get request() {
+    return this.original.request;
+  }
+  get url() {
+    return this.original.url;
+  }
+  get status() {
+    return this.original.status;
+  }
+  get headers() {
+    return this.original.headers;
+  }
+  get cookies() {
+    return this.original.cookies;
+  }
+  get remoteAddress() {
+    return this.original.remoteAddress;
+  }
+  get formData() {
+    return this.applyInterrupt(this.original.formData);
+  }
+  get text() {
+    return this.applyInterrupt(this.original.text);
+  }
+  get json() {
+    return this.applyInterrupt(this.original.json);
+  }
+  get urlParamsBody() {
+    return this.applyInterrupt(this.original.urlParamsBody);
+  }
+  get arrayBuffer() {
+    return this.applyInterrupt(this.original.arrayBuffer);
+  }
+  get upgrade() {
+    return this.applyInterrupt(this.original.upgrade);
+  }
+  [WebSourceSymbol]() {
+    const source = getWebSource(this.original);
+    if (source !== undefined)
+      responseRegistry.unregister(this.original);
+    return source;
+  }
+  get stream() {
+    return suspend4(() => {
+      responseRegistry.unregister(this.original);
+      return ensuring4(this.original.stream, sync2(() => {
+        this.controller.abort();
+      }));
+    });
+  }
+  toJSON() {
+    return this.original.toJSON();
+  }
+  [NodeInspectSymbol]() {
+    return this.original[NodeInspectSymbol]();
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+// node_modules/effect/dist/http/FetchHttpClient.js
+var Fetch = /* @__PURE__ */ Reference("effect/http/FetchHttpClient/Fetch", {
+  defaultValue: () => globalThis.fetch
+});
+var StreamBodyFallback = /* @__PURE__ */ Reference("effect/http/FetchHttpClient/StreamBodyFallback", {
+  defaultValue: () => "error"
+});
+
+class RequestInit extends (/* @__PURE__ */ Service()("effect/http/FetchHttpClient/RequestInit")) {
+}
+var supportsStreamBody;
+var detectStreamBodySupport = () => {
+  try {
+    let duplexAccessed = false;
+    const body = new ReadableStream;
+    const request = new Request("https://example.com", {
+      method: "POST",
+      body,
+      get duplex() {
+        duplexAccessed = true;
+        return "half";
+      }
+    });
+    return (duplexAccessed || request.body === body) && !request.headers.has("Content-Type");
+  } catch {
+    return false;
+  }
+};
+var fetch = /* @__PURE__ */ make33((request, url, signal, fiber) => {
+  if (request.headers.upgrade !== undefined) {
+    return fail7(new HttpClientError({
+      reason: new TransportError({
+        request,
+        description: "fetch cannot send an HTTP upgrade request"
+      })
+    }));
+  }
+  const fetch = fiber.getRef(Fetch);
+  const options = getOrUndefined2(fiber.context, RequestInit) ?? {};
+  let headers = options.headers ? merge4(fromInput(options.headers), request.headers) : request.headers;
+  if (headers["content-length"]) {
+    headers = remove3(headers, "content-length");
+  }
+  let uploadController;
+  const stopUpload = sync2(() => uploadController?.abort());
+  const send = (body) => map6(tryPromise2({
+    try: () => fetch(url, {
+      ...options,
+      method: request.method,
+      headers,
+      body,
+      duplex: typeof ReadableStream !== "undefined" && body instanceof ReadableStream ? "half" : undefined,
+      signal: uploadController ? AbortSignal.any([signal, uploadController.signal]) : signal
+    }),
+    catch: (cause) => new HttpClientError({
+      reason: new TransportError({
+        request,
+        cause
+      })
+    })
+  }), (response) => {
+    const original = fromWeb(request, response);
+    if (!uploadController)
+      return original;
+    if (response.body === null)
+      uploadController.abort();
+    return Object.create(original, {
+      ...Object.fromEntries(["arrayBuffer", "text", "json", "formData", "urlParamsBody"].map((key) => [key, {
+        get: () => ensuring2(original[key], stopUpload)
+      }])),
+      stream: {
+        get: () => ensuring4(original.stream, stopUpload)
+      }
+    });
+  }).pipe(onError2(() => stopUpload));
+  switch (request.body._tag) {
+    case "Raw":
+    case "Uint8Array":
+      return send(request.body.body);
+    case "FormData":
+      return send(request.body.formData);
+    case "Stream": {
+      supportsStreamBody ??= detectStreamBodySupport();
+      if (supportsStreamBody) {
+        uploadController = new AbortController;
+        const uploadSignal = AbortSignal.any([signal, uploadController.signal]);
+        const stopped = callback2((resume) => {
+          const onAbort = () => resume(interrupt2);
+          if (uploadSignal.aborted) {
+            onAbort();
+            return;
+          }
+          uploadSignal.addEventListener("abort", onAbort, {
+            once: true
+          });
+          return sync2(() => uploadSignal.removeEventListener("abort", onAbort));
+        });
+        return flatMap3(toReadableStreamEffect(interruptWhen2(request.body.stream, stopped)), send);
+      }
+      if (fiber.getRef(StreamBodyFallback) === "error") {
+        return fail7(new HttpClientError({
+          reason: new EncodeError({
+            request,
+            description: "Streaming request bodies are not supported in this runtime"
+          })
+        }));
+      }
+      return mkArrayBuffer(request.body.stream).pipe(mapError2((cause) => new HttpClientError({
+        reason: new EncodeError({
+          request,
+          cause
+        })
+      })), flatMap3(send));
+    }
+  }
+  return send(undefined);
+});
+var layer11 = /* @__PURE__ */ layerMergedContext(/* @__PURE__ */ succeed6(fetch));
 // src/environment.ts
 import { getSync } from "@dotenvx/dotenvx";
 var Environment = Literals(["development", "preview", "production", "ci"]);
@@ -17789,7 +19491,7 @@ var options = {
   strict: true
 };
 var read2 = fn2("Environment.read")(function* read(file) {
-  return yield* try_2({
+  return yield* try_3({
     catch: () => new UserError({
       cause: `Cannot load ${file}; check the file and its DOTENV_PRIVATE_KEY.`
     }),
@@ -17826,12 +19528,51 @@ var load = fn2("Environment.load")(function* load() {
 var exports = fn2("Environment.exports")(function* exports() {
   const { values } = yield* load();
   const variables = yield* decodeEffect2(ShellEnvironment, { onExcessProperty: "error" })(values).pipe(mapError2(() => new UserError({ cause: "Environment contains an invalid shell variable name." })));
-  const lines = yield* forEach2(toEntries(variables), ([key, value]) => fromResult2(quote(`${key}=${value}`, { format: "posix" })).pipe(map5((assignment) => `export ${assignment}`)));
+  const lines = yield* forEach2(toEntries(variables), ([key, value]) => fromResult2(quote(`${key}=${value}`, { format: "posix" })).pipe(map6((assignment) => `export ${assignment}`)));
   return join(lines, `
 `);
 });
 
+// src/process.ts
+var run6 = fn2("Process.run")(function* run(command) {
+  const child = yield* command;
+  const output = yield* child.stdout.pipe(decodeText2(), mkString);
+  const code = yield* child.exitCode;
+  if (code !== 0) {
+    return yield* new UserError({
+      cause: `${command.command} exited with status ${code}.`
+    });
+  }
+  return output;
+}, scoped2);
+var convex = (args, env, input) => run6(make18("bunx", ["--no-install", "convex", ...args], {
+  env,
+  extendEnv: true,
+  stderr: "inherit",
+  stdin: input === undefined ? "inherit" : make13(new TextEncoder().encode(input)),
+  stdout: "inherit"
+}));
+
 // src/deploy.ts
+var convexManagedEnvironmentNames = [
+  "CONVEX_DEPLOY_KEY",
+  "CONVEX_DEPLOYMENT_TOKEN",
+  "CONVEX_DEPLOYMENT",
+  "CONVEX_SELF_HOSTED_URL",
+  "CONVEX_SELF_HOSTED_ADMIN_KEY",
+  "CONVEX_URL",
+  "PUBLIC_CONVEX_URL",
+  "NEXT_PUBLIC_CONVEX_URL",
+  "VITE_CONVEX_URL",
+  "REACT_APP_CONVEX_URL",
+  "EXPO_PUBLIC_CONVEX_URL",
+  "CONVEX_SITE_URL",
+  "PUBLIC_CONVEX_SITE_URL",
+  "NEXT_PUBLIC_CONVEX_SITE_URL",
+  "VITE_CONVEX_SITE_URL",
+  "REACT_APP_CONVEX_SITE_URL",
+  "EXPO_PUBLIC_CONVEX_SITE_URL"
+];
 var deploy = fn2("Deploy.run")(function* deploy(build) {
   const environment = yield* load();
   const { target, values, file } = environment;
@@ -17845,7 +19586,8 @@ var deploy = fn2("Deploy.run")(function* deploy(build) {
     return yield* new UserError({ cause: "Preview deployment requires a branch name." });
   }
   const prefix = target === "preview" ? "preview:" : "prod:";
-  if (!(values["CONVEX_DEPLOY_KEY"] ?? "").startsWith(prefix)) {
+  const deployKey = values["CONVEX_DEPLOY_KEY"] ?? "";
+  if (!deployKey.startsWith(prefix)) {
     return yield* new UserError({
       cause: "Encrypted project file must contain a Convex deploy key matching VERCEL_ENV."
     });
@@ -17854,9 +19596,17 @@ var deploy = fn2("Deploy.run")(function* deploy(build) {
   if (build) {
     const cloud = yield* NonEmptyString2("NEXT_PUBLIC_CONVEX_URL");
     const site = yield* NonEmptyString2("NEXT_PUBLIC_CONVEX_SITE_URL");
-    const contents = yield* decrypt(file);
-    yield* convex(["env", "set", "--force", ...target === "preview" ? ["--preview-name", branch] : []], values, contents);
-    return yield* run6(make17("bun", ["run", "build"], {
+    const changes = map3(filter(toEntries(values), ([name]) => !contains(name)(convexManagedEnvironmentNames)), ([name, value]) => ({ name, value }));
+    if (changes.length > 0) {
+      yield* gen2(function* syncEnvironmentVariables() {
+        const client = yield* HttpClient;
+        const request = yield* bodyJson(setHeader(post(`${cloud}/api/v1/update_environment_variables`), "Authorization", `Convex ${deployKey}`), { changes });
+        yield* filterStatusOk2(client).execute(request).pipe(asVoid2);
+      }).pipe(provide3(layer11), mapError2(() => new UserError({
+        cause: "Could not synchronize Convex environment variables."
+      })));
+    }
+    return yield* run6(make18("bun", ["run", "build"], {
       env: { ...values, NEXT_PUBLIC_CONVEX_SITE_URL: site, NEXT_PUBLIC_CONVEX_URL: cloud },
       extendEnv: true,
       stderr: "inherit",
@@ -17873,10 +19623,22 @@ var deploy = fn2("Deploy.run")(function* deploy(build) {
   ], values).pipe(asVoid2);
 });
 
+// src/dotenv.ts
+var dotenvx = fn2("Dotenvx.run")(function* dotenvx(args, capture) {
+  const path = yield* Path;
+  const bin = yield* path.fromFileUrl(new URL("src/cli/dotenvx.js", import.meta.resolve("@dotenvx/dotenvx/package.json")));
+  return yield* run6(make18("bun", [bin, ...args], {
+    stderr: capture ? "ignore" : "inherit",
+    stdin: "inherit",
+    stdout: capture ? "pipe" : "inherit"
+  }));
+});
+var decrypt = (file) => dotenvx(["decrypt", "--stdout", "--no-armor", "--no-native", "-f", file], true);
+
 // src/run.ts
 var run7 = fn2("Run.command")(function* run(command, args) {
   const { values } = yield* load();
-  const child = yield* make17(command, args, {
+  const child = yield* make18(command, args, {
     env: { ...values, ...process.env },
     extendEnv: true,
     stderr: "inherit",
@@ -17938,15 +19700,117 @@ var setup = fn2("Setup.run")(function* setup() {
   return yield* log("Local Convex setup complete.");
 });
 
+// src/sync-dev.ts
+var failure = (cause) => new UserError({ cause });
+var reserved = /^(?:CONVEX_|DOTENV_|NEXT_PUBLIC_|PUBLIC_|VITE_|REACT_APP_|EXPO_PUBLIC_|VERCEL_|GITHUB_|NODE_|BUN_|AFFECT_|CI$|PATH$|HOME$|PWD$|SHELL$|ENV$|TMPDIR$|(?:HTTPS?|ALL|NO)_PROXY$)/u;
+var SettingName = String5.check(makeFilter2((name) => !reserved.test(name)));
+var Declaration2 = Record(String5, Struct({
+  isConvexValidator: Literal2(true),
+  isOptional: Literals(["required", "optional"])
+}));
+var Origin = URLFromString.check(makeFilter2((url) => url.protocol === "https:" && url.username === "" && url.password === "" && url.pathname === "/" && url.search === "" && url.hash === ""));
+var Profile = Struct({
+  CONVEX_DEPLOY_KEY: String5.check(isPattern2(/^dev:[a-z0-9-]+\|.+$/u)),
+  NEXT_PUBLIC_CONVEX_SITE_URL: Origin,
+  NEXT_PUBLIC_CONVEX_URL: Origin
+});
+var Slug = String5.check(isPattern2(/^[a-z0-9][a-z0-9_-]*$/u));
+var Id = Int.check(isGreaterThan2(0));
+var Identity = Struct({ project: Slug, projectId: Id, team: Slug, teamId: Id });
+var Deployment = Struct({
+  deploymentType: Literal2("dev"),
+  id: Id,
+  kind: Literal2("cloud"),
+  projectId: Id,
+  teamId: Id
+});
+var CanonicalUrls = Struct({ convexCloudUrl: Origin, convexSiteUrl: Origin });
+var Existing = Struct({
+  environmentVariables: Record(String5, String5)
+});
+var request = fn2("DevelopmentEnv.request")(function* request(url, authorization, body) {
+  const client = yield* HttpClient;
+  const base = setHeader(body === undefined ? get4(url) : post(url), "Authorization", authorization);
+  const outgoing = body === undefined ? base : yield* bodyJson(base, body);
+  const response = yield* client.execute(outgoing);
+  if (response.status !== 200) {
+    return yield* failure("Development environment request failed.");
+  }
+  return response;
+}, mapError2(() => failure("Development environment request failed.")));
+var json2 = (schema, response) => response.json.pipe(flatMap3(decodeUnknownEffect2(schema)), mapError2(() => failure("Invalid development deployment metadata.")));
+var syncDev = fn2("DevelopmentEnv.sync")(function* syncDev(force) {
+  const path = yield* Path;
+  const fs = yield* FileSystem;
+  const file = path.resolve("env", "development", ".env");
+  if (!(yield* fs.exists(file))) {
+    return yield* failure("Missing env/development/.env.");
+  }
+  yield* NonEmptyString2("DOTENV_PRIVATE_KEY").pipe(mapError2(() => failure("Set the matching development DOTENV_PRIVATE_KEY.")));
+  const values = yield* read2(file);
+  const profile = yield* decodeUnknownEffect2(Profile)(values).pipe(mapError2(() => failure("Development profile requires a dev-scoped key and HTTPS Convex origins.")));
+  const name = profile.CONVEX_DEPLOY_KEY.split("|")[0]?.slice(4);
+  if ((values["CONVEX_DEPLOYMENT"] ?? "") !== "" && values["CONVEX_DEPLOYMENT"] !== `dev:${name}`) {
+    return yield* failure("CONVEX_DEPLOYMENT does not match the development key.");
+  }
+  const declarationModule = yield* try_3({
+    catch: () => failure("Cannot load the declaration-only convex/env.config.ts."),
+    try: () => decodeUnknownEffect2(Struct({ default: Declaration2 }))(import.meta.require(path.resolve("convex", "env.config.ts")))
+  }).pipe(flatten3, mapError2(() => failure("Cannot load a valid declaration-only convex/env.config.ts with Convex validators.")));
+  const declaration = declarationModule.default;
+  yield* decodeEffect2(ArraySchema(SettingName))(keys(declaration)).pipe(mapError2(() => failure("Server declaration contains a credential, control or client-public name.")));
+  const entries = toEntries(declaration);
+  const missing = filter(entries, ([key, validator]) => validator.isOptional === "required" && !has(values, key));
+  if (missing.length > 0) {
+    return yield* failure(`Missing required server settings: ${join(map3(missing, ([key]) => key), ", ")}.`);
+  }
+  const selected = filterMap(entries, ([key]) => {
+    const value = has(values, key) ? values[key] : undefined;
+    return value === undefined ? failVoid : succeed2({ name: key, value });
+  });
+  const key = profile.CONVEX_DEPLOY_KEY;
+  const bearer = `Bearer ${key}`;
+  const lookup = { deployKey: key };
+  const cloud = yield* json2(Origin, yield* request("https://api.convex.dev/api/deployment/url_for_key", bearer, lookup));
+  if (cloud.origin !== profile.NEXT_PUBLIC_CONVEX_URL.origin) {
+    return yield* failure("Development key and public Convex URL do not match.");
+  }
+  const identity = yield* json2(Identity, yield* request("https://api.convex.dev/api/deployment/team_and_project_for_key", bearer, lookup));
+  const authorization = `Convex ${key}`;
+  const deployment = yield* json2(Deployment, yield* request(`${cloud.origin}/api/v1/deployment_info`, authorization));
+  if (deployment.teamId !== identity.teamId || deployment.projectId !== identity.projectId) {
+    return yield* failure("Development deployment identity does not match the key.");
+  }
+  const urls = yield* json2(CanonicalUrls, yield* request(`${cloud.origin}/api/v1/get_canonical_urls`, authorization));
+  if (urls.convexCloudUrl.origin !== cloud.origin || urls.convexSiteUrl.origin !== profile.NEXT_PUBLIC_CONVEX_SITE_URL.origin) {
+    return yield* failure("Development canonical Convex URLs do not match the profile.");
+  }
+  yield* error(`Convex target: ${identity.team}/${identity.project}; development ${name} (ID ${deployment.id}).`);
+  const existing = yield* json2(Existing, yield* request(`${cloud.origin}/api/v1/list_environment_variables`, authorization));
+  const changed = filter(selected, (entry) => !has(existing.environmentVariables, entry.name) || existing.environmentVariables[entry.name] !== entry.value);
+  const conflicts = filter(changed, (entry) => has(existing.environmentVariables, entry.name));
+  if (!force && conflicts.length > 0) {
+    return yield* failure(`Existing settings differ: ${join(map3(conflicts, (entry) => entry.name), ", ")}. Use --force to overwrite them.`);
+  }
+  if (changed.length > 0) {
+    yield* request(`${cloud.origin}/api/v1/update_environment_variables`, authorization, {
+      changes: changed
+    });
+  }
+  return yield* log(`Development settings: ${changed.length - conflicts.length} added, ${conflicts.length} updated, ${selected.length - changed.length} unchanged.`);
+}, provide3(layer11), provideService2(RequestInit, { redirect: "error" }));
+
 // src/index.ts
-var program = make27("affect").pipe(withDescription3("Environment and deployment commands for Affect applications."), withSubcommands([
-  make27("env", {}, () => exports().pipe(flatMap3(log))).pipe(withDescription3("Print shell exports for the selected encrypted environment.")),
-  make27("run", {
+var program = make30("affect").pipe(withDescription3("Environment and deployment commands for Affect applications."), withSubcommands([
+  make30("env", {}, () => exports().pipe(flatMap3(log))).pipe(withDescription3("Print shell exports for the selected encrypted environment."), withSubcommands([
+    make30("sync-dev", { force: Boolean6("force").pipe(withDefault5(false)) }, ({ force }) => syncDev(force)).pipe(withDescription3("Sync declared server settings to the verified hosted development backend; --force overwrites conflicts. No deployment."))
+  ])),
+  make30("run", {
     command: String10("command"),
     params: String10("args").pipe(variadic2())
   }, ({ command, params }) => run7(command, params)).pipe(withDescription3("Run a command with the selected encrypted environment.")),
-  make27("dotenvx", { args: String10("args").pipe(variadic2()) }, ({ args }) => dotenvx(args, false)).pipe(withDescription3("Run the bundled dotenvx CLI; pass its flags after --.")),
-  make27("setup", {}, setup).pipe(withDescription3("Initialize or retry an anonymous local Convex backend.")),
-  make27("deploy", { build: Boolean6("build").pipe(withDefault5(false)) }, ({ build }) => deploy(build)).pipe(withDescription3("Deploy the selected Vercel preview or production environment."))
+  make30("dotenvx", { args: String10("args").pipe(variadic2()) }, ({ args }) => dotenvx(args, false)).pipe(withDescription3("Run the bundled dotenvx CLI; pass its flags after --.")),
+  make30("setup", {}, setup).pipe(withDescription3("Initialize or retry an anonymous local Convex backend.")),
+  make30("deploy", { build: Boolean6("build").pipe(withDefault5(false)) }, ({ build }) => deploy(build)).pipe(withDescription3("Deploy the selected Vercel preview or production environment."))
 ]), run5({ version }), provide3(layer10), provideService2(LogToStderr2, true));
 runMain2(program);