@kitman-sh/cli 0.9.0 → 0.10.53

package/dist/chunk-11p4wf6n.js

@@ -0,0 +1,3551 @@
+// @bun
+import {
+  pipeArguments,
+  dual,
+  identity,
+  constant,
+  constTrue,
+  constVoid,
+  pipe,
+  memoize,
+  isNotUndefined,
+  hasProperty,
+  isTagged,
+  toJson,
+  assignProperty,
+  args,
+  evaluate,
+  PipeInspectableProto,
+  isExit,
+  causeFail,
+  makePrimitive,
+  exitSucceed,
+  exitFailCause,
+  exitFail,
+  withFiber,
+  Done,
+  Prototype,
+  String3,
+  mapInput,
+  none,
+  some,
+  isSome,
+  match,
+  getOrUndefined,
+  map4,
+  Service2,
+  add,
+  get4,
+  Reference,
+  fromInputUnsafe,
+  isFinite,
+  normalize,
+  succeed,
+  fail3,
+  isFailure,
+  isSuccess,
+  map5,
+  all2,
+  fromIterable,
+  isArrayNonEmpty,
+  isReadonlyArrayNonEmpty,
+  isCanonicalArrayIndex,
+  getUnsafe2,
+  sort,
+  of,
+  map6,
+  Error2,
+  TaggedError,
+  getCurrentFiber,
+  fiberJoin,
+  fiberInterrupt,
+  succeed2,
+  sync,
+  suspend2,
+  succeedNone,
+  void_,
+  callback2,
+  asSome,
+  andThen,
+  flatMap2,
+  exitInterrupt,
+  exitVoid,
+  exitZipRight,
+  scopeAddFinalizer,
+  scope,
+  onExitPrimitive,
+  onExitUnsafe,
+  uninterruptibleMask,
+  fiberRunIn,
+  makeLatchUnsafe,
+  makeLatch,
+  succeed3,
+  failCause2,
+  fail4,
+  interrupt2,
+  void_2,
+  isSuccess2,
+  isFailure2,
+  asVoidAll,
+  makeUnsafe5,
+  _await,
+  interruptWith,
+  doneUnsafe,
+  Scope,
+  makeUnsafe6,
+  provide,
+  addFinalizerExit,
+  addFinalizer,
+  forkUnsafe,
+  close,
+  isCause,
+  isFailReason,
+  isDieReason,
+  fromReasons,
+  die2,
+  makeFailReason,
+  makeDieReason,
+  squash,
+  isDone2,
+  Done2,
+  done,
+  reasonAnnotations,
+  catchDone,
+  isDoneCause,
+  filterDone,
+  doneExitFromCause,
+  matchEffect,
+  isEffect,
+  all3,
+  forEach,
+  whileLoop,
+  promise,
+  tryPromise,
+  succeed6,
+  suspend3,
+  sync2,
+  void_3,
+  callback3,
+  never,
+  gen,
+  fail7,
+  failCause3,
+  die3,
+  try_2,
+  yieldNow,
+  withFiber2,
+  fromResult,
+  flatMap3,
+  flatten,
+  andThen2,
+  tap2,
+  option2,
+  exit,
+  map8,
+  as,
+  asSome2,
+  asVoid,
+  zipWith,
+  catch_,
+  catchTag,
+  catchReason,
+  catchCause2,
+  catchIf,
+  mapError2,
+  orDie,
+  tapError2,
+  ignoreCause,
+  orElseSucceed,
+  sleep,
+  raceFirst,
+  when,
+  matchCauseEffect,
+  context,
+  contextWith,
+  provideContext2,
+  scope2,
+  scoped,
+  scopedWith,
+  ensuring2,
+  onError,
+  onExitPrimitive2,
+  onExit,
+  interrupt3,
+  onInterrupt,
+  uninterruptible,
+  uninterruptibleMask2,
+  forever,
+  forkChild,
+  forkIn,
+  runFork,
+  runForkWith,
+  runPromise,
+  fnUntraced,
+  mapEager,
+  flatMapEager,
+  catchEager,
+  Pointer,
+  passthrough,
+  transformEffect,
+  Transformation,
+  unknown,
+  getIndexSignatureKeys,
+  applyToSelfOrLastLinkEncoding,
+  decodeTo,
+  toEncoded,
+  decodeUnknownEffect,
+  SchemaError,
+  make18,
+  String4,
+  toCodecStringTree,
+  encodeUnknownJsonStringSync
+} from "./chunk-mbctzx7e.js";
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Iterable.js
+var headUnsafe = (self) => {
+  const iterator = self[Symbol.iterator]();
+  const result = iterator.next();
+  if (result.done)
+    throw new Error("headUnsafe: empty iterable");
+  return result.value;
+};
+var constEmpty = {
+  [Symbol.iterator]() {
+    return constEmptyIterator;
+  }
+};
+var constEmptyIterator = {
+  next() {
+    return {
+      done: true,
+      value: undefined
+    };
+  }
+};
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Record.js
+var has = /* @__PURE__ */ dual(2, (self, key) => Object.hasOwn(self, key));
+var map = /* @__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 makeEquivalence = (equivalence) => {
+  const is = isSubrecordBy(equivalence);
+  return (self, that) => is(self, that) && is(that, self);
+};
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/ByteSize.js
+var bigint0 = /* @__PURE__ */ BigInt(0);
+var bigint1 = /* @__PURE__ */ BigInt(1);
+var decimalBase = /* @__PURE__ */ BigInt(1000);
+var binaryBase = /* @__PURE__ */ BigInt(1024);
+var decimalUnits = [{
+  symbol: "B",
+  factor: bigint1,
+  names: ["B", "byte", "bytes"]
+}, {
+  symbol: "kB",
+  factor: decimalBase,
+  names: ["kB", "kilobyte", "kilobytes"]
+}, {
+  symbol: "MB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(2),
+  names: ["MB", "megabyte", "megabytes"]
+}, {
+  symbol: "GB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(3),
+  names: ["GB", "gigabyte", "gigabytes"]
+}, {
+  symbol: "TB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(4),
+  names: ["TB", "terabyte", "terabytes"]
+}, {
+  symbol: "PB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(5),
+  names: ["PB", "petabyte", "petabytes"]
+}, {
+  symbol: "EB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(6),
+  names: ["EB", "exabyte", "exabytes"]
+}, {
+  symbol: "ZB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(7),
+  names: ["ZB", "zettabyte", "zettabytes"]
+}, {
+  symbol: "YB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(8),
+  names: ["YB", "yottabyte", "yottabytes"]
+}, {
+  symbol: "RB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(9),
+  names: ["RB", "ronnabyte", "ronnabytes"]
+}, {
+  symbol: "QB",
+  factor: decimalBase ** /* @__PURE__ */ BigInt(10),
+  names: ["QB", "quettabyte", "quettabytes"]
+}];
+var binaryUnits = [decimalUnits[0], {
+  symbol: "KiB",
+  factor: binaryBase,
+  names: ["KiB", "kibibyte", "kibibytes"]
+}, {
+  symbol: "MiB",
+  factor: binaryBase ** /* @__PURE__ */ BigInt(2),
+  names: ["MiB", "mebibyte", "mebibytes"]
+}, {
+  symbol: "GiB",
+  factor: binaryBase ** /* @__PURE__ */ BigInt(3),
+  names: ["GiB", "gibibyte", "gibibytes"]
+}, {
+  symbol: "TiB",
+  factor: binaryBase ** /* @__PURE__ */ BigInt(4),
+  names: ["TiB", "tebibyte", "tebibytes"]
+}, {
+  symbol: "PiB",
+  factor: binaryBase ** /* @__PURE__ */ BigInt(5),
+  names: ["PiB", "pebibyte", "pebibytes"]
+}, {
+  symbol: "EiB",
+  factor: binaryBase ** /* @__PURE__ */ BigInt(6),
+  names: ["EiB", "exbibyte", "exbibytes"]
+}, {
+  symbol: "ZiB",
+  factor: binaryBase ** /* @__PURE__ */ BigInt(7),
+  names: ["ZiB", "zebibyte", "zebibytes"]
+}, {
+  symbol: "YiB",
+  factor: binaryBase ** /* @__PURE__ */ BigInt(8),
+  names: ["YiB", "yobibyte", "yobibytes"]
+}];
+var allUnits = [...decimalUnits, .../* @__PURE__ */ binaryUnits.slice(1)];
+var unitsByName = /* @__PURE__ */ new Map(/* @__PURE__ */ allUnits.flatMap((unit) => unit.names.map((name) => [name, unit])));
+var make = (value) => value;
+var invalid = (message) => {
+  throw new Error(`Invalid ByteSize: ${message}`);
+};
+var fromNumber = (input) => {
+  if (!Number.isSafeInteger(input) || input < 0) {
+    return invalid(`expected a non-negative safe integer, received ${input}`);
+  }
+  return make(BigInt(input));
+};
+var maxSafeInteger = /* @__PURE__ */ BigInt(Number.MAX_SAFE_INTEGER);
+var scaleDecimal = (quantity, factor) => {
+  const match = /^(\d+)(?:\.(\d+))?(?:e([+-]\d+))?$/.exec(quantity);
+  if (match === null)
+    return;
+  const fraction = match[2] ?? "";
+  const numerator = BigInt(match[1] + fraction) * factor;
+  const shift = Number(match[3] ?? 0) - fraction.length;
+  if (shift >= 0)
+    return numerator * BigInt(10) ** BigInt(shift);
+  const scale = BigInt(10) ** BigInt(-shift);
+  return numerator % scale === bigint0 ? numerator / scale : undefined;
+};
+var fromStringUnsafe = (input) => {
+  const match = /^\s*(\d+(?:\.\d+)?)\s*([A-Za-z]+)\s*$/.exec(input);
+  if (match === null)
+    return invalid(`unsupported syntax ${JSON.stringify(input)}`);
+  const unit = unitsByName.get(match[2]);
+  if (unit === undefined)
+    return invalid(`unsupported unit ${JSON.stringify(match[2])}`);
+  const value = scaleDecimal(match[1], unit.factor);
+  if (value === undefined)
+    return invalid(`${JSON.stringify(input)} does not represent an integral number of bytes`);
+  return make(value);
+};
+var fromInputUnsafe2 = (input) => {
+  switch (typeof input) {
+    case "bigint":
+      if (input < bigint0)
+        return invalid(`expected a non-negative bigint, received ${input}`);
+      return make(input);
+    case "number":
+      return fromNumber(input);
+    case "string":
+      return fromStringUnsafe(input);
+  }
+  return invalid(`unsupported input ${input}`);
+};
+var bytes = (value) => typeof value === "bigint" ? fromInputUnsafe2(value) : fromNumber(value);
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Fiber.js
+var join = fiberJoin;
+var interrupt = fiberInterrupt;
+var getCurrent = getCurrentFiber;
+var runIn = fiberRunIn;
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/internal/glob.js
+var maxExpansions = 1e4;
+var maxExpandedLength = 2 ** 22;
+var maxBraceDepth = 64;
+var compile = (patterns, dot) => {
+  const nodes = [];
+  const starts = new Set;
+  for (const pattern of patterns) {
+    for (const expanded of expandBraces(pattern)) {
+      const start = nodes.length;
+      if (compilePattern(expanded, nodes)) {
+        starts.add(start);
+      }
+    }
+  }
+  const initial = closure(nodes, starts);
+  return {
+    nodes,
+    initial,
+    dot,
+    masks: nodes.length <= 32 ? compileMasks(nodes, initial) : undefined
+  };
+};
+var compileMasks = (nodes, initial) => {
+  let start = 0;
+  for (const state of initial) {
+    start |= 1 << state;
+  }
+  let globstar = 0;
+  let end = 0;
+  let endFile = 0;
+  for (let i = 0;i < nodes.length; i++) {
+    const node = nodes[i];
+    const bit = 1 << i;
+    if (node._tag === "Globstar") {
+      globstar |= bit;
+    } else if (node._tag === "End") {
+      end |= bit;
+      if (!node.directoryOnly) {
+        endFile |= bit;
+      }
+    }
+  }
+  return {
+    initial: start,
+    globstar,
+    end,
+    endFile
+  };
+};
+var isUnc = (path) => path.startsWith("//") && path[2] !== undefined && path[2] !== "/";
+var compilePattern = (pattern, nodes) => {
+  if (pattern === "" || isUnc(pattern)) {
+    return false;
+  }
+  const raw = splitSegments(pattern);
+  const globstar = raw.indexOf("**");
+  if (globstar !== -1 && raw.some((segment, i) => i > globstar && (segment === "." || segment === ".."))) {
+    return false;
+  }
+  const {
+    directory,
+    segments
+  } = normalize2(raw);
+  if (segments.length === 0) {
+    return false;
+  }
+  for (const segment of segments) {
+    if (segment !== "**") {
+      nodes.push(compileSegment(Array.from(segment)));
+    } else if (nodes[nodes.length - 1] !== globstarNode) {
+      nodes.push(globstarNode);
+    }
+  }
+  nodes.push({
+    _tag: "End",
+    directoryOnly: directory
+  });
+  return true;
+};
+var globstarNode = {
+  _tag: "Globstar"
+};
+var splitSegments = (pattern) => {
+  const segments = [];
+  let start = 0;
+  for (let i = 0;i < pattern.length; i++) {
+    if (pattern[i] === "\\") {
+      i++;
+    } else if (pattern[i] === "/") {
+      segments.push(pattern.slice(start, i));
+      start = i + 1;
+    }
+  }
+  segments.push(pattern.slice(start));
+  return segments;
+};
+var drive = /^[A-Za-z]:/;
+var isDrive = (segment) => segment.length === 2 && drive.test(segment);
+var isRoot = (name) => name === "" || name.length === 3 && name[2] === "/" && drive.test(name);
+var isAbsolute = (path) => path.startsWith("/") || path[2] === "/" && drive.test(path);
+var normalize2 = (raw) => {
+  const segments = [];
+  let i = 0;
+  if (raw.length > 1 && (raw[0] === "" || isDrive(raw[0]))) {
+    segments.push(raw[0] === "" ? "" : `${raw[0]}/`);
+    i = 1;
+  }
+  let directory = false;
+  for (;i < raw.length; i++) {
+    const segment = raw[i];
+    if (segment === "" || segment === ".") {
+      directory = i === raw.length - 1 && segments.length > 0;
+    } else {
+      segments.push(segment);
+      directory = false;
+    }
+  }
+  if (segments.length === 0 && raw.includes(".")) {
+    segments.push(".");
+  }
+  return {
+    segments,
+    directory
+  };
+};
+var compileSegment = (chars) => {
+  const tokens = [];
+  let literal = "";
+  let magic = false;
+  let classes = true;
+  for (let i = 0;i < chars.length; i++) {
+    const char = chars[i];
+    if (char === "\\" && i + 1 < chars.length) {
+      literal += chars[++i];
+      tokens.push({
+        _tag: "Char",
+        code: chars[i].codePointAt(0)
+      });
+    } else if (char === "*") {
+      magic = true;
+      if (tokens[tokens.length - 1]?._tag !== "Star") {
+        tokens.push({
+          _tag: "Star"
+        });
+      }
+    } else if (char === "?") {
+      magic = true;
+      tokens.push({
+        _tag: "Any"
+      });
+    } else if (char === "[" && classes) {
+      const parsed = parseClass(chars, i);
+      if (parsed === undefined) {
+        classes = false;
+        literal += char;
+        tokens.push({
+          _tag: "Char",
+          code: char.codePointAt(0)
+        });
+      } else {
+        magic = true;
+        tokens.push(parsed.token);
+        i = parsed.end;
+      }
+    } else {
+      literal += char;
+      tokens.push({
+        _tag: "Char",
+        code: char.codePointAt(0)
+      });
+    }
+  }
+  if (!magic) {
+    return {
+      _tag: "Literal",
+      value: literal
+    };
+  }
+  const first = tokens[0];
+  return {
+    _tag: "Wildcard",
+    tokens,
+    leadingDot: first._tag === "Char" && first.code === 46,
+    affixes: compileAffixes(tokens)
+  };
+};
+var compileAffixes = (tokens) => {
+  let prefix = "";
+  let suffix;
+  for (const token of tokens) {
+    if (token._tag === "Star" && suffix === undefined) {
+      suffix = "";
+    } else if (token._tag === "Char" && (token.code < 55296 || token.code > 57343)) {
+      const char = String.fromCodePoint(token.code);
+      if (suffix === undefined) {
+        prefix += char;
+      } else {
+        suffix += char;
+      }
+    } else {
+      return;
+    }
+  }
+  return suffix === undefined ? undefined : {
+    prefix,
+    suffix
+  };
+};
+var range = (from, to) => [from.codePointAt(0), to.codePointAt(0)];
+var posixClasses = {
+  alnum: [.../* @__PURE__ */ range("0", "9"), .../* @__PURE__ */ range("A", "Z"), .../* @__PURE__ */ range("a", "z")],
+  alpha: [.../* @__PURE__ */ range("A", "Z"), .../* @__PURE__ */ range("a", "z")],
+  blank: [9, 9, 32, 32],
+  cntrl: [0, 31, 127, 127],
+  digit: /* @__PURE__ */ range("0", "9"),
+  graph: [33, 126],
+  lower: /* @__PURE__ */ range("a", "z"),
+  print: [32, 126],
+  punct: [33, 47, 58, 64, 91, 96, 123, 126],
+  space: [9, 13, 32, 32],
+  upper: /* @__PURE__ */ range("A", "Z"),
+  word: [.../* @__PURE__ */ range("0", "9"), .../* @__PURE__ */ range("A", "Z"), 95, 95, .../* @__PURE__ */ range("a", "z")],
+  xdigit: [.../* @__PURE__ */ range("0", "9"), .../* @__PURE__ */ range("A", "F"), .../* @__PURE__ */ range("a", "f")]
+};
+var parsePosixClass = (chars, open) => {
+  for (let i = open + 2;i < chars.length && i <= open + 8; i++) {
+    if (chars[i] === ":" && chars[i + 1] === "]") {
+      const ranges = posixClasses[chars.slice(open + 2, i).join("")];
+      return ranges === undefined ? undefined : {
+        ranges,
+        end: i + 1
+      };
+    }
+  }
+  return;
+};
+var parseClass = (chars, open) => {
+  let i = open + 1;
+  const negated = chars[i] === "!" || chars[i] === "^";
+  if (negated) {
+    i++;
+  }
+  const ranges = [];
+  for (let first = true;i < chars.length; i++, first = false) {
+    let char = chars[i];
+    if (char === "/") {
+      return;
+    }
+    if (char === "]" && !first) {
+      return {
+        token: {
+          _tag: "Class",
+          ranges,
+          negated
+        },
+        end: i
+      };
+    }
+    if (char === "[" && chars[i + 1] === ":") {
+      const posix = parsePosixClass(chars, i);
+      if (posix !== undefined) {
+        ranges.push(...posix.ranges);
+        i = posix.end;
+        continue;
+      }
+    }
+    if (char === "\\" && i + 1 < chars.length) {
+      char = chars[++i];
+    }
+    if (chars[i + 1] === "-" && i + 2 < chars.length && chars[i + 2] !== "]") {
+      let next = i + 2;
+      if (chars[next] === "/") {
+        return;
+      }
+      if (chars[next] === "\\" && next + 1 < chars.length) {
+        next++;
+      }
+      ranges.push(...range(char, chars[next]));
+      i = next;
+      continue;
+    }
+    ranges.push(...range(char, char));
+  }
+  return;
+};
+var expandBraces = (pattern) => {
+  const chars = Array.from(pattern);
+  const groups = matchBraceGroups(chars);
+  if (groups.size === 0) {
+    return [pattern];
+  }
+  const sequence = parseBraceSequence(chars, 0, chars.length, groups, 0);
+  if (sequence === undefined) {
+    return [pattern];
+  }
+  const count = countExpansions(sequence);
+  return count > maxExpansions || count * pattern.length > maxExpandedLength ? [pattern] : expandSequence(sequence);
+};
+var matchBraceGroups = (chars) => {
+  const groups = new Map;
+  const stack = [];
+  let classes = true;
+  for (let i = 0;i < chars.length; i++) {
+    const char = chars[i];
+    if (char === "\\") {
+      i++;
+    } else if (char === "/") {
+      classes = true;
+    } else if (char === "[" && classes) {
+      const parsed = parseClass(chars, i);
+      if (parsed === undefined) {
+        classes = false;
+      } else {
+        i = parsed.end;
+      }
+    } else if (char === "{") {
+      stack.push({
+        open: i,
+        commas: []
+      });
+    } else if (char === ",") {
+      stack[stack.length - 1]?.commas.push(i);
+    } else if (char === "}") {
+      const group = stack.pop();
+      if (group !== undefined && group.commas.length > 0) {
+        groups.set(group.open, {
+          commas: group.commas,
+          close: i
+        });
+      }
+    }
+  }
+  return groups;
+};
+var parseBraceSequence = (chars, start, end, groups, depth) => {
+  if (depth > maxBraceDepth) {
+    return;
+  }
+  const parts = [];
+  let text = "";
+  for (let i = start;i < end; i++) {
+    const group = groups.get(i);
+    if (group === undefined) {
+      if (chars[i] === "\\" && i + 1 < end) {
+        text += chars[i++];
+      }
+      text += chars[i];
+      continue;
+    }
+    const alternatives = [];
+    let from = i + 1;
+    for (const to of [...group.commas, group.close]) {
+      const alternative = parseBraceSequence(chars, from, to, groups, depth + 1);
+      if (alternative === undefined) {
+        return;
+      }
+      alternatives.push(alternative);
+      from = to + 1;
+    }
+    if (text !== "") {
+      parts.push(text);
+      text = "";
+    }
+    parts.push(alternatives);
+    i = group.close;
+  }
+  if (text !== "") {
+    parts.push(text);
+  }
+  return parts;
+};
+var countExpansions = (sequence) => {
+  let count = 1;
+  for (const part of sequence) {
+    if (typeof part !== "string") {
+      let sum = 0;
+      for (const alternative of part) {
+        sum += countExpansions(alternative);
+      }
+      count *= sum;
+      if (count > maxExpansions) {
+        return Infinity;
+      }
+    }
+  }
+  return count;
+};
+var expandSequence = (sequence) => {
+  let out = [""];
+  for (const part of sequence) {
+    if (typeof part === "string") {
+      out = out.map((prefix) => prefix + part);
+    } else {
+      const alternatives = part.flatMap(expandSequence);
+      out = out.flatMap((prefix) => alternatives.map((alternative) => prefix + alternative));
+    }
+  }
+  return out;
+};
+var matchToken = (token, code) => {
+  switch (token._tag) {
+    case "Char":
+      return token.code === code;
+    case "Any":
+      return true;
+    case "Star":
+      return false;
+    case "Class": {
+      let found = false;
+      for (let i = 0;i < token.ranges.length && !found; i += 2) {
+        found = code >= token.ranges[i] && code <= token.ranges[i + 1];
+      }
+      return found !== token.negated;
+    }
+  }
+};
+var width = (code) => code > 65535 ? 2 : 1;
+var matchWildcard = (node, name, dot) => {
+  if (name === "." || name === ".." || name.startsWith(".") && !dot && !node.leadingDot) {
+    return false;
+  }
+  if (node.affixes !== undefined) {
+    const {
+      prefix,
+      suffix
+    } = node.affixes;
+    return name.length >= prefix.length + suffix.length && name.startsWith(prefix) && name.endsWith(suffix);
+  }
+  const {
+    tokens
+  } = node;
+  let t = 0;
+  let c = 0;
+  let star = -1;
+  let resume = 0;
+  while (c < name.length) {
+    if (tokens[t]?._tag === "Star") {
+      star = t++;
+      resume = c;
+      continue;
+    }
+    const code = name.codePointAt(c);
+    if (t < tokens.length && matchToken(tokens[t], code)) {
+      t++;
+      c += width(code);
+    } else if (star !== -1) {
+      t = star + 1;
+      resume += width(name.codePointAt(resume));
+      c = resume;
+    } else {
+      return false;
+    }
+  }
+  while (tokens[t]?._tag === "Star") {
+    t++;
+  }
+  return t === tokens.length;
+};
+var closure = (nodes, states) => {
+  for (const state of states) {
+    if (nodes[state]._tag === "Globstar") {
+      states.add(state + 1);
+    }
+  }
+  return states;
+};
+var step = (compiled, states, name) => {
+  const explicit = new Set;
+  const viaGlobstar = new Set;
+  const root = isRoot(name);
+  for (const state of states) {
+    const node = compiled.nodes[state];
+    switch (node._tag) {
+      case "Globstar": {
+        if (!root && name !== "." && name !== ".." && (compiled.dot || !name.startsWith("."))) {
+          viaGlobstar.add(state);
+        }
+        break;
+      }
+      case "Literal": {
+        if (node.value === name) {
+          explicit.add(state + 1);
+        }
+        break;
+      }
+      case "Wildcard": {
+        if (!root && matchWildcard(node, name, compiled.dot)) {
+          explicit.add(state + 1);
+        }
+        break;
+      }
+    }
+  }
+  return {
+    explicit: closure(compiled.nodes, explicit),
+    globstar: closure(compiled.nodes, viaGlobstar)
+  };
+};
+var union = (step) => {
+  if (step.globstar.size === 0) {
+    return step.explicit;
+  }
+  const states = new Set(step.explicit);
+  for (const state of step.globstar) {
+    states.add(state);
+  }
+  return states;
+};
+var accepts = (compiled, states, isDirectory) => {
+  for (const state of states) {
+    const node = compiled.nodes[state];
+    if (node._tag === "End" && (isDirectory || !node.directoryOnly)) {
+      return true;
+    }
+  }
+  return false;
+};
+var canDescend = (compiled, states) => {
+  for (const state of states) {
+    if (compiled.nodes[state]._tag !== "End") {
+      return true;
+    }
+  }
+  return false;
+};
+var needsDirectory = (compiled, states) => {
+  for (const state of states) {
+    const node = compiled.nodes[state];
+    if (node._tag === "End" && node.directoryOnly) {
+      return true;
+    }
+  }
+  return false;
+};
+var join2 = (parent, name) => {
+  if (parent === "") {
+    return name === "" ? "/" : name;
+  }
+  return parent.endsWith("/") ? parent + name : `${parent}/${name}`;
+};
+var isMissing = (error) => error.reason._tag === "NotFound" || error.reason._tag === "BadResource";
+var isIgnorable = (error) => isMissing(error) || error.reason._tag === "PermissionDenied";
+var isNotLink = (error) => isIgnorable(error) || error.reason._tag === "Unknown";
+var DIRECTORY_CONCURRENCY = 16;
+var byName = /* @__PURE__ */ mapInput(String3, (entry) => entry.name);
+var make2 = (fs) => (pattern, options) => walk(fs, compile([pattern], options?.dot ?? false), options);
+var walk = /* @__PURE__ */ fnUntraced(function* (fs, compiled, options) {
+  if (compiled.initial.size === 0) {
+    return [];
+  }
+  const root = options?.root ?? "";
+  const excludes = compile(options?.exclude ?? [], true);
+  const excludeNeedsDirectory = excludes.nodes.some((node) => node._tag === "End" && node.directoryOnly);
+  const toFsPath = (relative) => isAbsolute(relative) ? relative : relative === "" ? root === "" ? "." : root : join2(root, relative);
+  const isUnlisted = (value) => value === "." || value === ".." || isRoot(value);
+  const probe = (parent, name, named) => {
+    const path = toFsPath(join2(parent, name));
+    return fs.stat(path).pipe(map8((info) => info.type), catchReason("PlatformError", "NotFound", () => fs.readLink(path).pipe(as("SymbolicLink"), catchIf(isNotLink, () => succeed6(undefined)))), catchIf(named ? isMissing : isIgnorable, () => succeed6(undefined)), map8((type) => type === undefined ? undefined : {
+      name,
+      type
+    }));
+  };
+  const entries = (relative, states, named) => {
+    const literals = new Set;
+    let listed = !named;
+    for (const state of states) {
+      const node = compiled.nodes[state];
+      if (node._tag === "Literal") {
+        literals.add(node.value);
+      } else if (node._tag !== "End") {
+        listed = true;
+      }
+    }
+    const probed = listed ? [...literals].filter(isUnlisted) : [...literals];
+    return zipWith(listed ? catchIf(fs.readDirectoryEntries(toFsPath(relative)), named ? isMissing : isIgnorable, () => succeed6([])) : succeed6([]), forEach(probed, (name) => probe(relative, name, named), {
+      concurrency: 16
+    }), (listing, found) => ({
+      entries: sort([...listing, ...found.filter(isNotUndefined)], byName),
+      named: named && !listed
+    }));
+  };
+  const visit = ({
+    name,
+    type
+  }, parent, states, excluded) => {
+    const result = step(compiled, states, name);
+    const next = union(result);
+    if (next.size === 0) {
+      return;
+    }
+    const relative = join2(parent, name);
+    const nextExcluded = union(step(excludes, excluded, name));
+    const descend = canDescend(compiled, next);
+    const child = (isDirectory, link) => {
+      const accepted = accepts(compiled, next, isDirectory);
+      if (!accepted && (!isDirectory || !descend) || accepts(excludes, nextExcluded, isDirectory)) {
+        return;
+      }
+      return {
+        relative,
+        accepted,
+        excluded: nextExcluded,
+        next: !isDirectory || !descend ? undefined : !link || result.globstar.size === 0 ? next : canDescend(compiled, result.explicit) ? result.explicit : undefined
+      };
+    };
+    if (!descend && !needsDirectory(compiled, next) && !excludeNeedsDirectory) {
+      return child(false, false);
+    }
+    if (type !== "Unknown" && type !== "SymbolicLink") {
+      return child(type === "Directory", false);
+    }
+    const path = toFsPath(relative);
+    return fs.stat(path).pipe(map8((info) => info.type === "Directory"), catchIf(isIgnorable, () => succeed6(false)), flatMap3((isDirectory) => {
+      const resolved = child(isDirectory, type === "SymbolicLink");
+      if (type === "SymbolicLink" || resolved?.next === undefined || result.globstar.size === 0) {
+        return succeed6(resolved);
+      }
+      return fs.readLink(path).pipe(as(child(isDirectory, true)), catchIf(isNotLink, () => succeed6(resolved)));
+    }));
+  };
+  let slots = DIRECTORY_CONCURRENCY;
+  let finishing = false;
+  const failed = makeUnsafe5();
+  const fork = (walk) => walk.pipe(onError((cause) => sync2(() => {
+    if (!finishing) {
+      doneUnsafe(failed, failCause3(cause));
+    }
+  })), ensuring2(sync2(() => {
+    slots++;
+  })), forkChild);
+  const directory = fnUntraced(function* (relative, states, excluded, named) {
+    const listing = yield* entries(relative, states, named);
+    const children = [];
+    const pending = [];
+    for (const entry of listing.entries) {
+      const child = visit(entry, relative, states, excluded);
+      if (isEffect(child)) {
+        const index = children.push(undefined) - 1;
+        pending.push(map8(child, (child) => {
+          children[index] = child;
+        }));
+      } else {
+        children.push(child);
+      }
+    }
+    if (pending.length > 0) {
+      yield* all3(pending, {
+        concurrency: 16,
+        discard: true
+      });
+    }
+    const subtrees = [];
+    for (const child of children) {
+      if (child?.next !== undefined) {
+        const walk = directory(child.relative, child.next, child.excluded, listing.named);
+        if (slots > 0) {
+          slots--;
+          subtrees.push(join(yield* fork(walk)));
+        } else {
+          subtrees.push(succeed6(yield* walk));
+        }
+      }
+    }
+    const out = [];
+    let index = 0;
+    for (const child of children) {
+      if (child === undefined) {
+        continue;
+      }
+      if (child.accepted) {
+        out.push(child.relative);
+      }
+      if (child.next !== undefined) {
+        for (const path of yield* subtrees[index++]) {
+          out.push(path);
+        }
+      }
+    }
+    return out;
+  });
+  return yield* raceFirst(ensuring2(directory("", compiled.initial, excludes.initial, true), sync2(() => {
+    finishing = true;
+  })), _await(failed));
+});
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/PlatformError.js
+var TypeId = "~effect/PlatformError";
+
+class BadArgument extends (/* @__PURE__ */ TaggedError("BadArgument")) {
+  get message() {
+    return `${this.module}.${this.method}${this.description ? `: ${this.description}` : ""}`;
+  }
+}
+
+class SystemError extends Error2 {
+  get message() {
+    return `${this._tag}: ${this.module}.${this.method}${this.pathOrDescriptor !== undefined ? ` (${this.pathOrDescriptor})` : ""}${this.description ? `: ${this.description}` : ""}`;
+  }
+}
+
+class PlatformError extends (/* @__PURE__ */ TaggedError("PlatformError")) {
+  constructor(reason) {
+    if ("cause" in reason) {
+      super({
+        reason,
+        cause: reason.cause
+      });
+    } else {
+      super({
+        reason
+      });
+    }
+  }
+  [TypeId] = TypeId;
+  get message() {
+    return this.reason.message;
+  }
+}
+var systemError = (options) => new PlatformError(new SystemError(options));
+var badArgument = (options) => new PlatformError(new BadArgument(options));
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Latch.js
+var makeUnsafe2 = makeLatchUnsafe;
+var make3 = makeLatch;
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/MutableRef.js
+var TypeId2 = "~effect/MutableRef";
+var MutableRefProto = {
+  [TypeId2]: TypeId2,
+  ...PipeInspectableProto,
+  toJSON() {
+    return {
+      _id: "MutableRef",
+      current: toJson(this.current)
+    };
+  }
+};
+var make8 = (value) => {
+  const ref = Object.create(MutableRefProto);
+  ref.current = value;
+  return ref;
+};
+var set = /* @__PURE__ */ dual(2, (self, value) => {
+  self.current = value;
+  return self;
+});
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/MutableList.js
+var Empty = /* @__PURE__ */ Symbol.for("effect/MutableList/Empty");
+var make4 = () => ({
+  head: undefined,
+  tail: undefined,
+  length: 0
+});
+var compactHead = (self) => {
+  const head = self.head;
+  if (head.offset >= 1024 && head === self.tail && head.mutable && (head.array.length - head.offset) * 8 <= head.offset) {
+    self.head = self.tail = {
+      array: head.array.slice(head.offset),
+      mutable: true,
+      offset: 0,
+      next: undefined
+    };
+  }
+};
+var emptyBucket = () => ({
+  array: [],
+  mutable: true,
+  offset: 0,
+  next: undefined
+});
+var append = (self, message) => {
+  if (!self.tail) {
+    self.head = self.tail = emptyBucket();
+  } else if (!self.tail.mutable) {
+    self.tail.next = emptyBucket();
+    self.tail = self.tail.next;
+  }
+  self.tail.array.push(message);
+  self.length++;
+};
+var prepend = (self, message) => {
+  self.head = {
+    array: [message],
+    mutable: true,
+    offset: 0,
+    next: self.head
+  };
+  if (!self.tail)
+    self.tail = self.head;
+  self.length++;
+};
+var appendAll = (self, messages) => appendAllUnsafe(self, Array.from(messages), true);
+var appendAllUnsafe = (self, messages, mutable = false) => {
+  if (messages.length === 0) {
+    return 0;
+  }
+  const chunk = {
+    array: messages,
+    mutable,
+    offset: 0,
+    next: undefined
+  };
+  if (self.head) {
+    self.tail = self.tail.next = chunk;
+  } else {
+    self.head = self.tail = chunk;
+  }
+  self.length += messages.length;
+  return messages.length;
+};
+var clear = (self) => {
+  self.head = self.tail = undefined;
+  self.length = 0;
+};
+var takeN = (self, n) => {
+  n = normalize(n);
+  if (n <= 0 || !self.head)
+    return [];
+  n = Math.min(n, self.length);
+  if (n === self.length && self.head?.offset === 0 && !self.head.next) {
+    const array = self.head.array;
+    clear(self);
+    return array;
+  }
+  const array = new Array(n);
+  let index = 0;
+  let chunk = self.head;
+  while (chunk) {
+    while (chunk.offset < chunk.array.length) {
+      array[index++] = chunk.array[chunk.offset];
+      if (chunk.mutable)
+        chunk.array[chunk.offset] = undefined;
+      chunk.offset++;
+      if (index === n) {
+        self.head = chunk.offset === chunk.array.length && chunk.next ? chunk.next : chunk;
+        self.length -= n;
+        if (self.length === 0)
+          clear(self);
+        else
+          compactHead(self);
+        return array;
+      }
+    }
+    chunk = chunk.next;
+  }
+  clear(self);
+  return array;
+};
+var takeAll = (self) => takeN(self, self.length);
+var take2 = (self) => {
+  if (!self.head)
+    return Empty;
+  const message = self.head.array[self.head.offset];
+  if (self.head.mutable)
+    self.head.array[self.head.offset] = undefined;
+  self.head.offset++;
+  self.length--;
+  if (self.head.offset === self.head.array.length) {
+    if (self.head.next) {
+      self.head = self.head.next;
+    } else {
+      clear(self);
+    }
+  } else {
+    compactHead(self);
+  }
+  return message;
+};
+var filter2 = (self, f) => {
+  const array = [];
+  let chunk = self.head;
+  let index = 0;
+  while (chunk) {
+    for (let i = chunk.offset;i < chunk.array.length; i++) {
+      if (f(chunk.array[i], index++)) {
+        array.push(chunk.array[i]);
+      }
+    }
+    chunk = chunk.next;
+  }
+  if (array.length === 0) {
+    clear(self);
+    return;
+  }
+  self.head = self.tail = {
+    array,
+    mutable: true,
+    offset: 0,
+    next: undefined
+  };
+  self.length = array.length;
+};
+var remove = (self, value) => filter2(self, (v) => v !== value);
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/PubSub.js
+var TypeId3 = "~effect/PubSub";
+var SubscriptionTypeId = "~effect/PubSub/Subscription";
+var make5 = (options) => sync2(() => makePubSubUnsafe(options.atomicPubSub(), new Map, makeUnsafe6(), makeUnsafe2(false), make8(false), options.strategy(), make8(none())));
+var unbounded = (options) => make5({
+  atomicPubSub: () => makeAtomicUnbounded(options),
+  strategy: () => new DroppingStrategy
+});
+var makeAtomicUnbounded = (options) => {
+  const replay = options?.replay;
+  return new UnboundedPubSub(replay && replay > 0 ? new ReplayBuffer(Math.ceil(replay)) : undefined);
+};
+var publishUnsafe = /* @__PURE__ */ dual(2, (self, value) => {
+  if (self.shutdownFlag.current || isSome(self.ended.current))
+    return false;
+  if (self.pubsub.publish(value)) {
+    self.strategy.completeSubscribersUnsafe(self.pubsub, self.subscribers);
+    return true;
+  }
+  return false;
+});
+var subscribe = (self) => uninterruptible(contextWith((services) => {
+  const localScope = get4(services, Scope);
+  const scope = forkUnsafe(self.scope);
+  const subscription = makeSubscriptionUnsafe(self.pubsub, self.subscribers, self.strategy, self.ended);
+  return addFinalizer(scope, unsubscribe(subscription)).pipe(andThen2(addFinalizerExit(localScope, (exit) => close(scope, exit))), as(subscription));
+}));
+var unsubscribe = (self) => uninterruptible(withFiber2((state) => {
+  set(self.shutdownFlag, true);
+  return forEach(takeAll(self.pollers), (d) => interruptWith(d, state.id), {
+    discard: true,
+    concurrency: "unbounded"
+  }).pipe(tap2(() => sync2(() => {
+    self.subscribers.delete(self.subscription);
+    self.subscription.unsubscribe();
+    self.replayWindow.close();
+    self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
+  })), when(self.shutdownHook.open), asVoid);
+}));
+var takeAll2 = (self) => suspend3(function loop(value) {
+  if (self.shutdownFlag.current) {
+    return interrupt3;
+  }
+  let as = self.pollers.length === 0 ? self.subscription.pollUpTo(Number.POSITIVE_INFINITY) : [];
+  if (value) {
+    as = value.concat(as);
+  }
+  self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
+  if (self.replayWindow.remaining > 0) {
+    return succeed6(self.replayWindow.takeAll().concat(as));
+  } else if (!isArrayNonEmpty(as)) {
+    return flatMap3(pollForItem(self), (item) => loop([item]));
+  }
+  return succeed6(as);
+});
+var pollForItem = (self) => callback3((resume) => {
+  if (self.shutdownFlag.current)
+    return resume(interrupt3);
+  if (isSome(self.ended.current)) {
+    const message = self.pollers.length === 0 ? self.subscription.poll() : Empty;
+    if (message !== Empty) {
+      self.strategy.onPubSubEmptySpaceUnsafe(self.pubsub, self.subscribers);
+      return resume(succeed6(message));
+    }
+    return resume(succeed6(self.ended.current.value));
+  }
+  const deferred = makeUnsafe5();
+  let set = self.subscribers.get(self.subscription);
+  if (!set) {
+    set = new Set;
+    self.subscribers.set(self.subscription, set);
+  }
+  set.add(self.pollers);
+  append(self.pollers, deferred);
+  self.strategy.completePollersUnsafe(self.pubsub, self.subscribers, self.subscription, self.pollers);
+  if (deferred.effect)
+    return resume(deferred.effect);
+  deferred.resumes = [resume];
+  return sync2(() => remove(self.pollers, deferred));
+});
+var AbsentValue = /* @__PURE__ */ Symbol.for("effect/PubSub/AbsentValue");
+var addSubscribers = (subscribers, subscription, pollers) => {
+  if (!subscribers.has(subscription)) {
+    subscribers.set(subscription, new Set);
+  }
+  const set = subscribers.get(subscription);
+  set.add(pollers);
+};
+var removeSubscribers = (subscribers, subscription, pollers) => {
+  if (!subscribers.has(subscription)) {
+    return;
+  }
+  const set = subscribers.get(subscription);
+  set.delete(pollers);
+  if (set.size === 0) {
+    subscribers.delete(subscription);
+  }
+};
+var makeSubscriptionUnsafe = (pubsub, subscribers, strategy, ended) => new SubscriptionImpl(pubsub, subscribers, pubsub.subscribe(), make4(), makeUnsafe2(false), make8(false), strategy, pubsub.replayWindow(), ended);
+class UnboundedPubSub {
+  publisherHead = {
+    value: AbsentValue,
+    replayIndex: undefined,
+    subscribers: 0,
+    next: null
+  };
+  publisherTail = this.publisherHead;
+  publisherIndex = 0;
+  subscribersIndex = 0;
+  capacity = Number.MAX_SAFE_INTEGER;
+  replayBuffer;
+  constructor(replayBuffer) {
+    this.replayBuffer = replayBuffer;
+  }
+  replayWindow() {
+    return this.replayBuffer ? new ReplayWindowImpl(this.replayBuffer) : emptyReplayWindow;
+  }
+  isEmpty() {
+    return this.publisherHead === this.publisherTail;
+  }
+  isFull() {
+    return false;
+  }
+  size() {
+    return this.publisherIndex - this.subscribersIndex;
+  }
+  publish(value) {
+    const replayIndex = this.replayBuffer?.offer(value);
+    const subscribers = this.publisherTail.subscribers;
+    if (subscribers !== 0) {
+      const node = {
+        value,
+        replayIndex,
+        subscribers,
+        next: null
+      };
+      this.publisherTail.next = node;
+      this.publisherTail = this.publisherTail.next;
+      this.publisherIndex += 1;
+    }
+    return true;
+  }
+  publishAll(elements) {
+    if (this.publisherTail.subscribers !== 0) {
+      for (const a of elements) {
+        this.publish(a);
+      }
+    } else if (this.replayBuffer) {
+      this.replayBuffer.offerAll(elements);
+    }
+    return [];
+  }
+  slide() {
+    if (this.publisherHead !== this.publisherTail) {
+      const node = this.publisherHead.next;
+      const value = node.value;
+      this.publisherHead = this.publisherHead.next;
+      this.publisherHead.value = AbsentValue;
+      this.subscribersIndex += 1;
+      this.replayBuffer?.slide(value, node.replayIndex);
+    }
+  }
+  subscribe() {
+    this.publisherTail.subscribers += 1;
+    return new UnboundedPubSubSubscription(this, this.publisherTail, this.publisherIndex, false);
+  }
+}
+
+class UnboundedPubSubSubscription {
+  self;
+  subscriberHead;
+  subscriberIndex;
+  unsubscribed;
+  constructor(self, subscriberHead, subscriberIndex, unsubscribed) {
+    this.self = self;
+    this.subscriberHead = subscriberHead;
+    this.subscriberIndex = subscriberIndex;
+    this.unsubscribed = unsubscribed;
+  }
+  isEmpty() {
+    if (this.unsubscribed) {
+      return true;
+    }
+    let empty = true;
+    let loop = true;
+    while (loop) {
+      if (this.subscriberHead === this.self.publisherTail) {
+        loop = false;
+      } else {
+        if (this.subscriberHead.next.value !== AbsentValue) {
+          empty = false;
+          loop = false;
+        } else {
+          this.subscriberHead = this.subscriberHead.next;
+          this.subscriberIndex += 1;
+        }
+      }
+    }
+    return empty;
+  }
+  size() {
+    if (this.unsubscribed) {
+      return 0;
+    }
+    return this.self.publisherIndex - Math.max(this.subscriberIndex, this.self.subscribersIndex);
+  }
+  poll() {
+    if (this.unsubscribed) {
+      return Empty;
+    }
+    let loop = true;
+    let polled = Empty;
+    while (loop) {
+      if (this.subscriberHead === this.self.publisherTail) {
+        loop = false;
+      } else {
+        const elem = this.subscriberHead.next.value;
+        if (elem !== AbsentValue) {
+          polled = elem;
+          this.subscriberHead.subscribers -= 1;
+          if (this.subscriberHead.subscribers === 0) {
+            this.self.publisherHead = this.self.publisherHead.next;
+            this.self.publisherHead.value = AbsentValue;
+            this.self.subscribersIndex += 1;
+          }
+          loop = false;
+        }
+        this.subscriberHead = this.subscriberHead.next;
+        this.subscriberIndex += 1;
+      }
+    }
+    return polled;
+  }
+  pollUpTo(n) {
+    n = normalize(n);
+    const builder = [];
+    let i = 0;
+    while (i !== n) {
+      const a = this.poll();
+      if (a === Empty) {
+        i = n;
+      } else {
+        builder.push(a);
+        i += 1;
+      }
+    }
+    return builder;
+  }
+  unsubscribe() {
+    if (!this.unsubscribed) {
+      this.unsubscribed = true;
+      this.self.publisherTail.subscribers -= 1;
+      while (this.subscriberHead !== this.self.publisherTail) {
+        if (this.subscriberHead.next.value !== AbsentValue) {
+          this.subscriberHead.subscribers -= 1;
+          if (this.subscriberHead.subscribers === 0) {
+            this.self.publisherHead = this.self.publisherHead.next;
+            this.self.publisherHead.value = AbsentValue;
+            this.self.subscribersIndex += 1;
+          }
+        }
+        this.subscriberHead = this.subscriberHead.next;
+      }
+    }
+  }
+}
+
+class SubscriptionImpl {
+  [SubscriptionTypeId] = {
+    _A: identity
+  };
+  pubsub;
+  subscribers;
+  subscription;
+  pollers;
+  shutdownHook;
+  shutdownFlag;
+  strategy;
+  replayWindow;
+  ended;
+  constructor(pubsub, subscribers, subscription, pollers, shutdownHook, shutdownFlag, strategy, replayWindow, ended) {
+    this.pubsub = pubsub;
+    this.subscribers = subscribers;
+    this.subscription = subscription;
+    this.pollers = pollers;
+    this.shutdownHook = shutdownHook;
+    this.shutdownFlag = shutdownFlag;
+    this.strategy = strategy;
+    this.replayWindow = replayWindow;
+    this.ended = ended;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+
+class PubSubImpl {
+  [TypeId3] = {
+    _A: identity
+  };
+  pubsub;
+  subscribers;
+  scope;
+  shutdownHook;
+  shutdownFlag;
+  strategy;
+  ended;
+  constructor(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy, ended) {
+    this.pubsub = pubsub;
+    this.subscribers = subscribers;
+    this.scope = scope;
+    this.shutdownHook = shutdownHook;
+    this.shutdownFlag = shutdownFlag;
+    this.strategy = strategy;
+    this.ended = ended;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+}
+var makePubSubUnsafe = (pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy, ended) => new PubSubImpl(pubsub, subscribers, scope, shutdownHook, shutdownFlag, strategy, ended);
+class DroppingStrategy {
+  get shutdown() {
+    return void_3;
+  }
+  handleSurplus(_pubsub, _subscribers, _elements, _isShutdown) {
+    return succeed6(false);
+  }
+  onPubSubEmptySpaceUnsafe(_pubsub, _subscribers) {}
+  completePollersUnsafe(pubsub, subscribers, subscription, pollers) {
+    return strategyCompletePollersUnsafe(this, pubsub, subscribers, subscription, pollers);
+  }
+  completeSubscribersUnsafe(pubsub, subscribers) {
+    return strategyCompleteSubscribersUnsafe(this, pubsub, subscribers);
+  }
+}
+var strategyCompletePollersUnsafe = (strategy, pubsub, subscribers, subscription, pollers) => {
+  let keepPolling = true;
+  while (keepPolling && !subscription.isEmpty()) {
+    const poller = take2(pollers);
+    if (poller === Empty) {
+      removeSubscribers(subscribers, subscription, pollers);
+      if (pollers.length === 0) {
+        keepPolling = false;
+      } else {
+        addSubscribers(subscribers, subscription, pollers);
+      }
+    } else {
+      const pollResult = subscription.poll();
+      if (pollResult === Empty) {
+        prepend(pollers, poller);
+      } else {
+        doneUnsafe(poller, succeed3(pollResult));
+        strategy.onPubSubEmptySpaceUnsafe(pubsub, subscribers);
+      }
+    }
+  }
+};
+var strategyCompleteSubscribersUnsafe = (strategy, pubsub, subscribers) => {
+  for (const [subscription, pollersSet] of subscribers) {
+    for (const pollers of pollersSet) {
+      strategy.completePollersUnsafe(pubsub, subscribers, subscription, pollers);
+    }
+  }
+};
+
+class ReplayBuffer {
+  capacity;
+  head = {
+    value: AbsentValue,
+    index: 0,
+    next: null
+  };
+  tail = this.head;
+  slideValues = [];
+  size = 0;
+  index = 0;
+  publisherIndex = 0;
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  slide(value, publisherIndex) {
+    this.slideValues[this.index % this.capacity] = {
+      value,
+      index: publisherIndex
+    };
+    this.index++;
+  }
+  offer(a) {
+    const index = this.publisherIndex++;
+    this.tail.value = a;
+    this.tail.index = index;
+    this.tail.next = {
+      value: AbsentValue,
+      index: 0,
+      next: null
+    };
+    this.tail = this.tail.next;
+    if (this.size === this.capacity) {
+      const dropped = this.head;
+      this.head = dropped.next;
+      dropped.next = null;
+      dropped.value = AbsentValue;
+    } else {
+      this.size += 1;
+    }
+    return index;
+  }
+  offerAll(as) {
+    for (const a of as) {
+      this.offer(a);
+    }
+  }
+}
+
+class ReplayWindowImpl {
+  buffer;
+  values;
+  index = 0;
+  remaining;
+  slideIndex;
+  newestIndex = -1;
+  constructor(buffer) {
+    this.buffer = buffer;
+    this.remaining = buffer.size;
+    this.slideIndex = buffer.index;
+    this.values = new Array(this.remaining);
+    let node = buffer.head;
+    for (let i = 0;i < this.remaining; i++) {
+      this.values[i] = node.value;
+      this.newestIndex = node.index;
+      node = node.next;
+    }
+  }
+  close() {
+    this.values.length = 0;
+    this.remaining = 0;
+  }
+  sync() {
+    const slides = this.buffer.index - this.slideIndex;
+    if (slides === 0 || this.remaining === 0) {
+      return;
+    }
+    const count = Math.min(slides, this.buffer.capacity);
+    const start = this.buffer.index - count;
+    for (let i = 0;i < count; i++) {
+      const entry = this.buffer.slideValues[(start + i) % this.buffer.capacity];
+      if (entry.index > this.newestIndex) {
+        this.index = (this.index + 1) % this.values.length;
+        this.values[(this.index + this.remaining - 1) % this.values.length] = entry.value;
+        this.newestIndex = entry.index;
+      }
+    }
+    this.slideIndex = this.buffer.index;
+  }
+  take() {
+    if (this.remaining === 0) {
+      return;
+    }
+    this.sync();
+    const value = this.values[this.index];
+    this.values[this.index] = AbsentValue;
+    this.index = (this.index + 1) % this.values.length;
+    this.remaining--;
+    if (this.remaining === 0) {
+      this.close();
+    }
+    return value;
+  }
+  takeN(n) {
+    n = normalize(n);
+    const len = Math.min(n, this.remaining);
+    const items = new Array(len);
+    for (let i = 0;i < len; i++) {
+      items[i] = this.take();
+    }
+    return items;
+  }
+  takeAll() {
+    return this.takeN(this.remaining);
+  }
+}
+var emptyReplayWindow = {
+  remaining: 0,
+  take: () => {
+    return;
+  },
+  takeN: () => [],
+  takeAll: () => [],
+  close: () => {
+    return;
+  }
+};
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Queue.js
+var TypeId4 = "~effect/Queue";
+var EnqueueTypeId = "~effect/Queue/Enqueue";
+var DequeueTypeId = "~effect/Queue/Dequeue";
+var variance = {
+  _A: identity,
+  _E: identity
+};
+var QueueProto = {
+  [TypeId4]: variance,
+  [EnqueueTypeId]: variance,
+  [DequeueTypeId]: variance,
+  ...PipeInspectableProto,
+  toJSON() {
+    return {
+      _id: "effect/Queue",
+      state: this.state._tag,
+      size: sizeUnsafe(this)
+    };
+  }
+};
+var make9 = (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 = make4();
+  self.scheduleRunning = false;
+  self.state = {
+    _tag: "Open",
+    takers: new Set,
+    offers: new Set,
+    awaiters: new Set
+  };
+  return succeed2(self);
+});
+var bounded = (capacity) => make9({
+  capacity
+});
+var sliding = (capacity) => make9({
+  capacity,
+  strategy: "sliding"
+});
+var unbounded2 = () => make9();
+var offer = /* @__PURE__ */ dual(2, (self, message) => suspend2(() => offerUnsafe(self, message) ? exitTrue : self.state._tag === "Open" && self.strategy === "suspend" ? offerOrWait(self, message) : exitFalse));
+var offerUnsafe = (self, message) => {
+  if (self.state._tag !== "Open") {
+    return false;
+  } else if (self.messages.length >= self.capacity) {
+    if (self.strategy === "sliding") {
+      take2(self.messages);
+      append(self.messages, message);
+      return true;
+    } else if (self.capacity <= 0 && self.state.takers.size > 0) {
+      append(self.messages, message);
+      releaseTakers(self);
+      return true;
+    }
+    return false;
+  }
+  append(self.messages, message);
+  scheduleReleaseTaker(self);
+  return true;
+};
+var offerAll = /* @__PURE__ */ dual(2, (self, messages) => callback2((resume) => {
+  const remaining = offerAllUnsafe(self, messages);
+  if (remaining.length === 0 || self.strategy === "dropping") {
+    return resume(exitSucceed(remaining));
+  }
+  return waitToOffer(self, {
+    _tag: "Array",
+    remaining,
+    offset: 0,
+    resume
+  });
+}));
+var offerAllUnsafe = (self, messages) => {
+  if (self.state._tag !== "Open") {
+    return fromIterable(messages);
+  } else if (self.capacity === Number.POSITIVE_INFINITY || self.strategy === "sliding") {
+    appendAll(self.messages, messages);
+    if (self.strategy === "sliding") {
+      takeN(self.messages, self.messages.length - self.capacity);
+    }
+    scheduleReleaseTaker(self);
+    return [];
+  }
+  const free = self.capacity <= 0 ? self.state.takers.size : self.capacity - self.messages.length;
+  if (free === 0) {
+    return fromIterable(messages);
+  }
+  const remaining = [];
+  let i = 0;
+  for (const message of messages) {
+    if (i < free) {
+      append(self.messages, message);
+    } else {
+      remaining.push(message);
+    }
+    i++;
+  }
+  scheduleReleaseTaker(self);
+  return remaining;
+};
+var fail = /* @__PURE__ */ dual(2, (self, error) => failCause(self, causeFail(error)));
+var failCause = /* @__PURE__ */ dual(2, (self, cause) => sync(() => failCauseUnsafe(self, cause)));
+var failCauseUnsafe = (self, cause) => {
+  if (self.state._tag !== "Open") {
+    return false;
+  }
+  const exit = exitFailCause(cause);
+  const fail = exitZipRight(exit, exitFailDone);
+  if (self.state.offers.size === 0 && self.messages.length === 0) {
+    finalize(self, fail);
+    return true;
+  }
+  self.state = {
+    ...self.state,
+    _tag: "Closing",
+    exit: fail
+  };
+  scheduleReleaseTaker(self);
+  return true;
+};
+var end = (self) => failCause(self, causeFail(Done()));
+var endUnsafe = (self) => failCauseUnsafe(self, causeFail(Done()));
+var shutdown = (self) => sync(() => shutdownUnsafe(self));
+var shutdownUnsafe = (self) => {
+  if (self.state._tag === "Done") {
+    return false;
+  }
+  clear(self.messages);
+  const offers = self.state.offers;
+  finalize(self, self.state._tag === "Open" ? exitInterrupt2 : self.state.exit);
+  for (const entry of offers) {
+    resumeUnoffered(entry);
+  }
+  return true;
+};
+var takeAll3 = (self) => takeBetween(self, 1, Number.POSITIVE_INFINITY);
+var takeBetween = /* @__PURE__ */ dual(3, (self, min, max) => {
+  min = normalize(min);
+  max = normalize(max);
+  return suspendTake(() => takeBetweenUnsafe(self, min, max) ?? andThen(awaitTake(self, () => canTake(self, min)), takeBetween(self, min, max)));
+});
+var take = (self) => suspendTake(() => takeUnsafe(self) ?? andThen(awaitTake(self, () => canTake(self, 1)), take(self)));
+var poll = (self) => suspendTake(() => {
+  const result = takeUnsafe(self);
+  if (result === undefined) {
+    return succeed2(none());
+  }
+  if (result._tag === "Success") {
+    return succeed2(some(result.value));
+  }
+  return succeed2(none());
+});
+var takeUnsafe = (self) => {
+  if (self.state._tag === "Done") {
+    return self.state.exit;
+  }
+  if (self.messages.length > 0) {
+    const message = take2(self.messages);
+    releaseCapacity(self);
+    return exitSucceed(message);
+  } else if (self.capacity <= 0 && self.state.offers.size > 0) {
+    const message = takeOfferUnsafe(self.state.offers);
+    releaseCapacity(self);
+    return exitSucceed(message);
+  }
+  return;
+};
+var sizeUnsafe = (self) => self.state._tag === "Done" ? 0 : self.messages.length;
+var exitFalse = /* @__PURE__ */ exitSucceed(false);
+var exitTrue = /* @__PURE__ */ exitSucceed(true);
+var exitFailDone = /* @__PURE__ */ exitFail(/* @__PURE__ */ Done());
+var exitInterrupt2 = /* @__PURE__ */ exitInterrupt();
+var releaseTakers = (self) => {
+  if (self.state._tag === "Done" || self.state.takers.size === 0) {
+    return;
+  }
+  for (const taker of self.state.takers) {
+    if (!taker.ready())
+      continue;
+    self.state.takers.delete(taker);
+    taker.resume(exitVoid);
+    if (self.messages.length === 0) {
+      break;
+    }
+  }
+};
+var scheduleReleaseTaker = (self) => {
+  if (self.scheduleRunning || self.state._tag === "Done" || self.state.takers.size === 0) {
+    return;
+  }
+  self.scheduleRunning = true;
+  self.dispatcher.scheduleTask(() => {
+    self.scheduleRunning = false;
+    releaseTakers(self);
+  }, 0);
+};
+var takeBetweenUnsafe = (self, min, max) => {
+  if (self.state._tag === "Done") {
+    return self.state.exit;
+  } else if (max <= 0 || min <= 0) {
+    return exitSucceed([]);
+  } else if (!canTake(self, min)) {
+    return;
+  }
+  const messages = self.messages.length > 0 ? takeN(self.messages, max) : [takeOfferUnsafe(self.state.offers)];
+  releaseCapacity(self);
+  return exitSucceed(messages);
+};
+var suspendTake = /* @__PURE__ */ makePrimitive({
+  op: "QueueTake",
+  [evaluate](fiber) {
+    const effect = this[args]();
+    return isExit(effect) ? effect[evaluate](fiber) : effect;
+  }
+});
+var canTake = (self, min) => self.messages.length >= (self.state._tag === "Closing" ? 1 : Math.min(min, self.capacity || 1)) || self.capacity <= 0 && self.state._tag !== "Done" && self.state.offers.size > 0;
+var awaitTake = (self, ready) => callback2((resume) => {
+  if (self.state._tag === "Done")
+    return resume(self.state.exit);
+  if (ready())
+    return resume(exitVoid);
+  const taker = {
+    ready,
+    resume
+  };
+  self.state.takers.add(taker);
+  return sync(() => {
+    if (self.state._tag !== "Done")
+      self.state.takers.delete(taker);
+  });
+});
+var offerOrWait = (self, message) => callback2((resume) => offerUnsafe(self, message) ? resume(exitTrue) : waitToOffer(self, {
+  _tag: "Single",
+  message,
+  resume
+}));
+var waitToOffer = (self, entry) => {
+  if (self.state._tag !== "Open")
+    return resumeUnoffered(entry);
+  const offers = self.state.offers;
+  offers.add(entry);
+  return sync(() => {
+    if (self.state._tag === "Done")
+      return;
+    offers.delete(entry);
+    if (self.state._tag === "Closing" && offers.size === 0 && self.messages.length === 0) {
+      finalize(self, self.state.exit);
+    }
+  });
+};
+var resumeUnoffered = (entry) => entry._tag === "Single" ? entry.resume(exitFalse) : entry.resume(exitSucceed(entry.remaining.slice(entry.offset)));
+var takeOfferUnsafe = (offers) => {
+  const entry = offers.values().next().value;
+  if (entry._tag === "Single") {
+    offers.delete(entry);
+    entry.resume(exitTrue);
+    return entry.message;
+  }
+  const message = entry.remaining[entry.offset++];
+  if (entry.offset === entry.remaining.length) {
+    offers.delete(entry);
+    entry.resume(exitSucceed([]));
+  }
+  return message;
+};
+var releaseCapacity = (self) => {
+  if (self.state._tag === "Done") {
+    return isDoneCause(self.state.exit.cause);
+  } else if (self.state.offers.size === 0) {
+    if (self.state._tag === "Closing" && self.messages.length === 0) {
+      finalize(self, self.state.exit);
+      return isDoneCause(self.state.exit.cause);
+    }
+    return false;
+  }
+  for (const entry of self.state.offers) {
+    let n = self.capacity - self.messages.length;
+    if (n <= 0)
+      break;
+    else if (entry._tag === "Single") {
+      append(self.messages, entry.message);
+      self.state.offers.delete(entry);
+      entry.resume(exitTrue);
+    } else {
+      for (;entry.offset < entry.remaining.length; entry.offset++) {
+        if (n === 0)
+          return false;
+        append(self.messages, entry.remaining[entry.offset]);
+        n--;
+      }
+      self.state.offers.delete(entry);
+      entry.resume(exitSucceed([]));
+    }
+    const state = self.state;
+    if (state._tag === "Done") {
+      return isDoneCause(state.exit.cause);
+    }
+  }
+  return false;
+};
+var finalize = (self, exit) => {
+  if (self.state._tag === "Done") {
+    return;
+  }
+  const openState = self.state;
+  self.state = {
+    _tag: "Done",
+    exit
+  };
+  for (const taker of openState.takers) {
+    taker.resume(exit);
+  }
+  openState.takers.clear();
+  for (const awaiter of openState.awaiters) {
+    awaiter(exit);
+  }
+  openState.awaiters.clear();
+};
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Semaphore.js
+var makeUnsafe3 = (permits) => new SemaphoreImpl(permits);
+var firstAvailableWaiter = (self) => {
+  for (const waiter of self.waiters) {
+    if (waiter.permits <= self.free)
+      return waiter;
+  }
+};
+var takePermits = (self, n, onAcquire, restore = identity) => withFiber((fiber) => {
+  if (self.free >= n && firstAvailableWaiter(self) === undefined) {
+    self.taken += n;
+    return onAcquire();
+  }
+  const waiter = {
+    permits: n,
+    resume: undefined
+  };
+  const remove = () => {
+    if (self.waiters.delete(waiter))
+      self.releaseUnsafe(fiber, 0);
+    return;
+  };
+  self.waiters.add(waiter);
+  onExitUnsafe(fiber, remove);
+  const wait = restore(callback2((resume) => {
+    if (firstAvailableWaiter(self) === waiter) {
+      resume(void_);
+    } else {
+      waiter.resume = resume;
+    }
+  }));
+  const loop = flatMap2(wait, () => {
+    if (firstAvailableWaiter(self) !== waiter)
+      return loop;
+    self.taken += n;
+    remove();
+    return onAcquire();
+  });
+  return loop;
+});
+
+class SemaphoreImpl {
+  waiters = /* @__PURE__ */ new Set;
+  taken = 0;
+  permits;
+  constructor(permits) {
+    this.permits = permits;
+  }
+  get free() {
+    return this.permits - this.taken;
+  }
+  take(n) {
+    return takePermits(this, n, () => succeed2(n));
+  }
+  takeScoped(n) {
+    return uninterruptibleMask((restore) => flatMap2(scope, (scope) => takePermits(this, n, () => scopeAddFinalizer(scope, this.release(n)), restore)));
+  }
+  takeIfAvailable(n) {
+    return suspend2(() => {
+      if (this.free < n)
+        return succeed2(false);
+      this.taken += n;
+      return succeed2(true);
+    });
+  }
+  releaseUnsafe(fiber, n) {
+    this.taken -= n;
+    if (this.waiters.size > 0) {
+      fiber.currentDispatcher.scheduleTask(() => {
+        let remaining = this.free;
+        for (const waiter of Array.from(this.waiters)) {
+          if (!this.waiters.has(waiter) || waiter.permits > remaining)
+            continue;
+          remaining -= waiter.permits;
+          const resume = waiter.resume;
+          waiter.resume = undefined;
+          resume?.(void_);
+        }
+      }, 0);
+    }
+    return this.free;
+  }
+  resize(permits) {
+    return withFiber((fiber) => {
+      this.permits = permits;
+      if (this.free < 0)
+        return void_;
+      this.releaseUnsafe(fiber, 0);
+      return void_;
+    });
+  }
+  release(n) {
+    return withFiber((fiber) => succeed2(this.releaseUnsafe(fiber, n)));
+  }
+  get releaseAll() {
+    return withFiber((fiber) => succeed2(this.releaseUnsafe(fiber, this.taken)));
+  }
+  withPermits(n) {
+    return (self) => uninterruptibleMask((restore) => takePermits(this, n, () => onExitPrimitive(restore(self), () => {
+      this.releaseUnsafe(getCurrentFiber(), n);
+      return;
+    }, true), restore));
+  }
+  withPermit = /* @__PURE__ */ this.withPermits(1);
+  withPermitsIfAvailable(n) {
+    return (self) => uninterruptibleMask((restore) => {
+      if (this.free < n)
+        return succeedNone;
+      this.taken += n;
+      return onExitPrimitive(restore(asSome(self)), () => {
+        this.releaseUnsafe(getCurrentFiber(), n);
+        return;
+      }, true);
+    });
+  }
+}
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Channel.js
+var TypeId5 = "~effect/Channel";
+var isChannel = (u) => hasProperty(u, TypeId5);
+var ChannelProto = {
+  [TypeId5]: {
+    _Env: identity,
+    _InErr: identity,
+    _InElem: identity,
+    _OutErr: identity,
+    _OutElem: identity
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var fromTransform = (transform) => {
+  const self = Object.create(ChannelProto);
+  self.transform = (upstream, scope) => catchCause2(transform(upstream, scope), (cause) => succeed6(failCause3(cause)));
+  return self;
+};
+var transformPull = (self, f) => fromTransform((upstream, scope) => flatMap3(toTransform(self)(upstream, scope), (pull) => f(pull, scope)));
+var fromPull = (effect) => fromTransform((_, __) => effect);
+var fromTransformBracket = (f) => fromTransform(fnUntraced(function* (upstream, scope) {
+  const closableScope = forkUnsafe(scope);
+  const onCause = (cause) => close(closableScope, doneExitFromCause(cause));
+  const pull = yield* onError(f(upstream, scope, closableScope), onCause);
+  return onError(pull, onCause);
+}));
+var toTransform = (channel) => channel.transform;
+var asyncQueue = (scope, f, options) => make9({
+  capacity: options?.bufferSize,
+  strategy: options?.strategy
+}).pipe(tap2((queue) => addFinalizer(scope, shutdown(queue))), tap2((queue) => provide(f(queue), scope).pipe(catchCause2((cause) => failCause(queue, cause)), forkIn(scope, {
+  startImmediately: true
+}))));
+var callbackArray = (f, options) => fromTransform((_, scope) => map8(asyncQueue(scope, f, options), takeAll3));
+var suspend4 = (evaluate) => fromTransform((upstream, scope) => suspend3(() => toTransform(evaluate())(upstream, scope)));
+var fromIterator = (iterator) => fromPull(sync2(() => {
+  const iter = iterator();
+  return suspend3(() => {
+    const state = iter.next();
+    return state.done ? done(state.value) : succeed6(state.value);
+  });
+}));
+var succeed4 = (value) => fromEffect(succeed6(value));
+var empty = /* @__PURE__ */ fromPull(/* @__PURE__ */ succeed6(/* @__PURE__ */ done()));
+var fail5 = (error) => fromPull(succeed6(fail7(error)));
+var failCause4 = (cause) => fromPull(failCause3(cause));
+var die = (defect) => failCause4(die2(defect));
+var fromEffect = (effect) => fromPull(sync2(() => {
+  let done2 = false;
+  return suspend3(() => {
+    if (done2)
+      return done();
+    done2 = true;
+    return effect;
+  });
+}));
+var fromEffectDrain = (effect) => fromPull(flatMap3(effect, () => done()));
+var fromQueueArray = (queue) => fromPull(succeed6(takeAll3(queue)));
+var fromSubscriptionArray = (subscription) => fromPull(succeed6(onInterrupt(takeAll2(subscription), () => done())));
+var fromPubSubArray = (pubsub) => unwrap2(map8(subscribe(pubsub), fromSubscriptionArray));
+var fromReadableStream2 = (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 = suspend3(() => {
+    if (exit.current)
+      return exit.current;
+    return matchCauseEffect(tryPromise({
+      try: () => reader.read(),
+      catch: options.onError
+    }), {
+      onFailure: (cause) => exit.current ?? failCause3(cause),
+      onSuccess: ({
+        done: done2,
+        value
+      }) => {
+        if (exit.current)
+          return exit.current;
+        return done2 ? done() : succeed6(of(value));
+      }
+    });
+  });
+  return as(addFinalizer(options.scope, options.releaseLockOnEnd ? sync2(() => reader.releaseLock()) : promise(() => reader.cancel().catch((error) => reader.closed.then(() => Promise.reject(error), constVoid))).pipe(ensuring2(sync2(() => reader.releaseLock())))), pull);
+};
+var map7 = /* @__PURE__ */ dual(2, (self, f) => transformPull(self, (pull) => sync2(() => {
+  let i = 0;
+  return map8(pull, (o) => f(o, i++));
+})));
+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, (done2) => flatMap3(f(done2), done)))));
+var concurrencyIsSequential = (concurrency) => concurrency === undefined || concurrency !== "unbounded" && concurrency <= 1;
+var mapEffect = /* @__PURE__ */ dual((args) => isChannel(args[0]), (self, f, options) => concurrencyIsSequential(options?.concurrency) ? mapEffectSequential(self, f) : mapEffectConcurrent(self, f, options));
+var mapEffectSequential = (self, f) => fromTransform((upstream, scope) => {
+  let i = 0;
+  return map8(toTransform(self)(upstream, scope), flatMap3((o) => f(o, i++)));
+});
+var mapEffectConcurrent = (self, f, options) => fromTransformBracket(fnUntraced(function* (upstream, scope, forkedScope) {
+  let i = 0;
+  const pull = yield* toTransform(self)(upstream, scope);
+  const concurrencyN = options.concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : Math.min(options.concurrency, Number.MAX_SAFE_INTEGER);
+  const queue = yield* bounded(0);
+  yield* addFinalizer(forkedScope, shutdown(queue));
+  const runFork = runForkWith(yield* context());
+  const trackFiber = runIn(forkedScope);
+  if (options.unordered) {
+    const semaphore = makeUnsafe3(concurrencyN);
+    const release = constant(semaphore.release(1));
+    const handle = matchCauseEffect({
+      onFailure: (cause) => flatMap3(failCause(queue, cause), release),
+      onSuccess: (value) => flatMap3(offer(queue, value), release)
+    });
+    yield* semaphore.take(1).pipe(flatMap3(() => pull), flatMap3((value) => {
+      const index = i++;
+      trackFiber(runFork(handle(suspend3(() => f(value, index)))));
+      return void_3;
+    }), forever({
+      disableYield: true
+    }), catchCause2((cause) => semaphore.withPermits(concurrencyN - 1)(failCause(queue, cause))), forkIn(forkedScope));
+  } else {
+    const effects = yield* bounded(concurrencyN - 2);
+    yield* addFinalizer(forkedScope, shutdown(effects));
+    yield* take(effects).pipe(flatten, flatMap3((value) => offer(queue, value)), forever({
+      disableYield: true
+    }), catchCause2((cause) => failCause(queue, cause)), forkIn(forkedScope));
+    let errorCause;
+    const onExit = (exit) => {
+      if (exit._tag === "Success")
+        return;
+      errorCause = exit.cause;
+      failCauseUnsafe(queue, exit.cause);
+    };
+    yield* pull.pipe(flatMap3((value) => {
+      if (errorCause)
+        return failCause3(errorCause);
+      const index = i++;
+      const fiber = runFork(suspend3(() => f(value, index)));
+      trackFiber(fiber);
+      fiber.addObserver(onExit);
+      return offer(effects, join(fiber));
+    }), forever({
+      disableYield: true
+    }), catchCause2((cause) => offer(effects, failCause2(cause)).pipe(andThen2(failCause(effects, cause)))), forkIn(forkedScope));
+  }
+  return take(queue);
+}));
+var flatMap = /* @__PURE__ */ dual((args) => isChannel(args[0]), (self, f, options) => concurrencyIsSequential(options?.concurrency) ? flatMapSequential(self, f) : flatMapConcurrent(self, f, options));
+var flatMapSequential = (self, f) => fromTransform((upstream, scope) => map8(toTransform(self)(upstream, scope), (pull) => {
+  let childPull;
+  let childScope;
+  const makePull = flatMap3(pull, (value) => {
+    childScope ??= forkUnsafe(scope);
+    return flatMapEager(toTransform(f(value))(upstream, childScope), (pull) => {
+      childPull = catchHalt(pull);
+      return childPull;
+    });
+  });
+  const catchHalt = catchDone((_) => {
+    childPull = undefined;
+    if (childScope.state._tag === "Empty") {
+      return makePull;
+    }
+    const close2 = close(childScope, void_2);
+    childScope = undefined;
+    return flatMap3(close2, () => makePull);
+  });
+  return suspend3(() => childPull ?? makePull);
+}));
+var flatMapConcurrent = (self, f, options) => self.pipe(map7(f), mergeAll(options));
+var flatten2 = (channels) => flatMap(channels, identity);
+var flattenArray = (self) => transformPull(self, (pull) => {
+  let array;
+  let index = 0;
+  const pump = suspend3(function loop() {
+    if (array === undefined) {
+      return flatMap3(pull, (array_) => {
+        switch (array_.length) {
+          case 0:
+            return loop();
+          case 1:
+            return succeed6(array_[0]);
+          default: {
+            array = array_;
+            return succeed6(array_[index++]);
+          }
+        }
+      });
+    }
+    const next = array[index++];
+    if (index >= array.length) {
+      array = undefined;
+      index = 0;
+    }
+    return succeed6(next);
+  });
+  return succeed6(pump);
+});
+var filterArray = /* @__PURE__ */ dual(2, (self, predicate) => transformPull(self, (pull) => succeed6(flatMap3(pull, function loop(arr) {
+  const passes = [];
+  for (let i = 0;i < arr.length; i++) {
+    if (predicate(arr[i])) {
+      passes.push(arr[i]);
+    }
+  }
+  return isReadonlyArrayNonEmpty(passes) ? succeed6(passes) : flatMap3(pull, loop);
+}))));
+var catchCause3 = /* @__PURE__ */ dual(2, (self, f) => fromTransform((upstream, scope) => {
+  let forkedScope = forkUnsafe(scope);
+  return map8(toTransform(self)(upstream, forkedScope), (pull) => {
+    let currentPull = pull.pipe(catchCause2((cause) => {
+      if (isDoneCause(cause)) {
+        return failCause3(cause);
+      }
+      const toClose = forkedScope;
+      forkedScope = forkUnsafe(scope);
+      return close(toClose, failCause2(cause)).pipe(andThen2(toTransform(f(cause))(upstream, forkedScope)), flatMap3((childPull) => {
+        currentPull = childPull;
+        return childPull;
+      }));
+    }));
+    return suspend3(() => currentPull);
+  });
+}));
+var tapError3 = /* @__PURE__ */ dual(2, (self, f) => transformPull(self, (pull) => succeed6(tapError2(pull, (err) => isDone2(err) ? void_3 : asVoid(f(err))))));
+var mapError3 = /* @__PURE__ */ dual(2, (self, f) => transformPull(self, (pull) => succeed6(mapError2(pull, (err) => isDone2(err) ? err : f(err)))));
+var mergeAll = /* @__PURE__ */ dual(2, (channels, {
+  bufferSize = 16,
+  concurrency,
+  switch: switch_ = false
+}) => fromTransformBracket(fnUntraced(function* (upstream, scope, forkedScope) {
+  const concurrencyN = concurrency === "unbounded" ? Number.MAX_SAFE_INTEGER : Math.max(1, concurrency);
+  const semaphore = switch_ ? undefined : makeUnsafe3(concurrencyN);
+  const doneLatch = yield* make3(true);
+  const fibers = new Map;
+  const queue = yield* bounded(bufferSize);
+  yield* addFinalizer(forkedScope, shutdown(queue));
+  const pull = yield* toTransform(channels)(upstream, scope);
+  yield* gen(function* () {
+    while (true) {
+      let pullFiber;
+      if (semaphore) {
+        if (fibers.size < concurrencyN) {
+          yield* semaphore.take(1);
+        } else {
+          pullFiber = yield* forkChild(pull);
+          yield* raceFirst(semaphore.take(1), andThen2(join(pullFiber), never));
+        }
+      }
+      const channel = pullFiber === undefined ? yield* pull : yield* join(pullFiber);
+      const childScope = forkUnsafe(forkedScope);
+      const childPull = yield* toTransform(channel)(upstream, childScope);
+      while (fibers.size >= concurrencyN) {
+        const [fiber, fiberScope] = headUnsafe(fibers);
+        fibers.delete(fiber);
+        if (fibers.size === 0)
+          yield* doneLatch.open;
+        yield* interrupt(fiber);
+        yield* ignoreCause(close(fiberScope, interrupt2()));
+      }
+      const fiber = yield* childPull.pipe(tap2(() => yieldNow), flatMap3((value) => offer(queue, value)), forever({
+        disableYield: true
+      }), onError(fnUntraced(function* (cause) {
+        const exit2 = doneExitFromCause(cause);
+        const closeExit = yield* exit(close(childScope, exit2));
+        if (!fibers.has(fiber))
+          return;
+        const failure = asVoidAll([exit2, closeExit]);
+        if (isFailure2(failure))
+          yield* failCause(queue, failure.cause);
+        fibers.delete(fiber);
+        if (semaphore)
+          yield* semaphore.release(1);
+        if (fibers.size === 0)
+          yield* doneLatch.open;
+      })), forkChild);
+      doneLatch.closeUnsafe();
+      fibers.set(fiber, childScope);
+    }
+  }).pipe(catchCause2((cause) => {
+    const halt = filterDone(cause);
+    if (isSuccess(halt)) {
+      return doneLatch.whenOpen(failCause(queue, cause));
+    }
+    return failCause(queue, cause);
+  }), forkIn(forkedScope));
+  return take(queue);
+})));
+var merge = /* @__PURE__ */ dual((args) => isChannel(args[0]) && isChannel(args[1]), (left, right, options) => fromTransformBracket(fnUntraced(function* (upstream, _scope, forkedScope) {
+  const strategy = options?.haltStrategy ?? "both";
+  const queue = yield* bounded(0);
+  yield* addFinalizer(forkedScope, shutdown(queue));
+  let done = 0;
+  function onExit(side, cause) {
+    done++;
+    if (!isDoneCause(cause)) {
+      return failCause(queue, cause);
+    }
+    switch (strategy) {
+      case "both": {
+        return done === 2 ? failCause(queue, cause) : void_3;
+      }
+      case "left":
+      case "right": {
+        return side === strategy ? failCause(queue, cause) : void_3;
+      }
+      case "either": {
+        return failCause(queue, cause);
+      }
+    }
+  }
+  const runSide = (side, channel, scope) => toTransform(channel)(upstream, scope).pipe(flatMap3((pull) => pull.pipe(flatMap3((value) => offer(queue, value)), forever)), onError((cause) => onExitPrimitive2(doneExitFromCause(cause), (exit) => close(scope, exit)).pipe(matchCauseEffect({
+    onFailure: (cause) => onExit(side, cause),
+    onSuccess: () => onExit(side, cause)
+  }))), forkIn(forkedScope));
+  yield* runSide("left", left, forkUnsafe(forkedScope));
+  yield* runSide("right", right, forkUnsafe(forkedScope));
+  return take(queue);
+})));
+var mergeEffect = /* @__PURE__ */ dual(2, (self, effect) => merge(self, fromEffectDrain(effect), {
+  haltStrategy: "left"
+}));
+var splitLines2 = () => fromTransform((upstream, _scope) => sync2(() => {
+  let stringBuilder = "";
+  let midCRLF = false;
+  let done2 = none();
+  function splitLinesArray(chunk) {
+    const chunkBuilder = [];
+    function pushLine(segment) {
+      if (stringBuilder.length === 0) {
+        chunkBuilder.push(segment);
+      } else {
+        chunkBuilder.push(stringBuilder + segment);
+        stringBuilder = "";
+      }
+    }
+    for (let i = 0;i < chunk.length; i++) {
+      const str = chunk[i];
+      if (str.length !== 0) {
+        let from = 0;
+        let indexOfCR = str.indexOf("\r");
+        let indexOfLF = str.indexOf(`
+`);
+        if (midCRLF) {
+          if (indexOfLF === 0) {
+            from = 1;
+            indexOfLF = str.indexOf(`
+`, from);
+          }
+          midCRLF = false;
+        }
+        while (indexOfCR !== -1 || indexOfLF !== -1) {
+          if (indexOfCR === -1 || indexOfLF !== -1 && indexOfLF < indexOfCR) {
+            pushLine(str.substring(from, indexOfLF));
+            from = indexOfLF + 1;
+            indexOfLF = str.indexOf(`
+`, from);
+          } else {
+            pushLine(str.substring(from, indexOfCR));
+            if (str.length === indexOfCR + 1) {
+              midCRLF = true;
+              from = str.length;
+              indexOfCR = -1;
+            } else {
+              from = indexOfCR + (indexOfLF === indexOfCR + 1 ? 2 : 1);
+              indexOfCR = str.indexOf("\r", from);
+              indexOfLF = str.indexOf(`
+`, from);
+            }
+          }
+        }
+        stringBuilder = stringBuilder + str.substring(from);
+      }
+    }
+    return isReadonlyArrayNonEmpty(chunkBuilder) ? chunkBuilder : null;
+  }
+  const pullOrFlush = suspend3(() => {
+    if (done2._tag === "Some") {
+      return done(done2.value);
+    }
+    return matchEffect(upstream, {
+      onSuccess: loop,
+      onFailure: failCause3,
+      onDone: (leftover) => {
+        done2 = some(leftover);
+        if (stringBuilder.length > 0) {
+          const last = stringBuilder;
+          stringBuilder = "";
+          midCRLF = false;
+          return succeed6([last]);
+        }
+        return done(leftover);
+      }
+    });
+  });
+  function loop(chunk) {
+    const lines = splitLinesArray(chunk);
+    return lines !== null ? succeed6(lines) : pullOrFlush;
+  }
+  return pullOrFlush;
+}));
+var decodeText2 = (encoding, options) => fromTransform((upstream, _scope) => sync2(() => {
+  const decoder = new TextDecoder(encoding, options);
+  const streamOptions = {
+    stream: true
+  };
+  let pull = upstream.pipe(map8(map6((bytes) => decoder.decode(bytes, streamOptions))), catchDone((leftover) => {
+    pull = done(leftover);
+    const last = decoder.decode();
+    return last.length > 0 ? succeed6(of(last)) : pull;
+  }));
+  return suspend3(() => pull);
+}));
+var pipeTo = /* @__PURE__ */ dual(2, (self, that) => fromTransform((upstream, scope) => flatMap3(toTransform(self)(upstream, scope), (upstream) => toTransform(that)(upstream, scope))));
+var isUpstreamFailure = (reason) => reason._tag === "Die" && isDone2(reason.defect) && isCause(reason.defect.value);
+var hasUpstreamFailure = (cause) => cause.reasons.some(isUpstreamFailure);
+var upstreamFailureToDefect = (pull) => catchCause2(pull, (cause) => isDoneCause(cause) ? failCause3(cause) : die3(Done2(cause)));
+var unwrapUpstreamFailure = (cause) => hasUpstreamFailure(cause) ? fromReasons(cause.reasons.flatMap((reason) => isUpstreamFailure(reason) ? reason.defect.value.reasons : [reason])) : cause;
+var restoreUpstreamFailure = (effect) => catchCause2(effect, (cause) => failCause3(unwrapUpstreamFailure(cause)));
+var unwrap2 = (channel) => fromTransform((upstream, scope) => {
+  let pull;
+  return succeed6(suspend3(() => {
+    if (pull)
+      return pull;
+    return channel.pipe(provide(scope), flatMap3((channel) => toTransform(channel)(upstream, scope)), flatMap3((pull_) => pull = pull_));
+  }));
+});
+var interruptWhen2 = /* @__PURE__ */ dual(2, (self, effect) => merge(self, fromPull(succeed6(flatMap3(effect, done))), {
+  haltStrategy: "either"
+}));
+var onExit2 = /* @__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) => onExit2(self, (_) => finalizer));
+var runWith = (self, f, onHalt) => suspend3(() => {
+  const scope = makeUnsafe6();
+  const makePull = toTransform(self)(done(), scope);
+  return catchDone(flatMap3(makePull, f), onHalt ? onHalt : succeed6).pipe(onExit((exit) => close(scope, exit)));
+});
+var provideContext3 = /* @__PURE__ */ dual(2, (self, context) => fromTransform((upstream, scope) => map8(provideContext2(toTransform(self)(upstream, scope), context), provideContext2(context))));
+var runDrain2 = (self) => runWith(self, (pull) => forever(pull, {
+  disableYield: true
+}));
+var runForEach2 = /* @__PURE__ */ dual(2, (self, f) => runWith(self, (pull) => forever(flatMap3(pull, f), {
+  disableYield: true
+})));
+var mkUint8Array = (self) => map8(runFold2(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 runHead2 = (self) => suspend3(() => {
+  let head = none();
+  return runWith(self, (pull) => pull.pipe(asSome2, flatMap3((head_) => {
+    head = head_;
+    return done();
+  })), () => succeed6(head));
+});
+var runFold2 = /* @__PURE__ */ dual(3, (self, initial, f) => suspend3(() => {
+  let state = initial();
+  return runWith(self, (pull) => whileLoop({
+    while: constTrue,
+    body: () => pull,
+    step: (value) => {
+      state = f(state, value);
+    }
+  }), () => succeed6(state));
+}));
+var toPullScoped = (self, scope) => toTransform(self)(done(), scope);
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/internal/stream.js
+var TypeId6 = "~effect/Stream";
+var streamVariance = {
+  _R: identity,
+  _E: identity,
+  _A: identity
+};
+var Stream = function(channel) {
+  this.channel = channel;
+};
+Stream.prototype = {
+  [TypeId6]: streamVariance,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var fromChannel3 = (channel) => new Stream(channel);
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Sink.js
+var TypeId7 = "~effect/Sink";
+var endVoid = /* @__PURE__ */ succeed6([undefined]);
+var sinkVariance = {
+  _A: identity,
+  _In: identity,
+  _L: identity,
+  _E: identity,
+  _R: identity
+};
+var SinkProto = {
+  [TypeId7]: sinkVariance,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var isSink = (u) => hasProperty(u, TypeId7);
+var fromChannel = (channel) => fromTransform2((upstream, scope) => toTransform(channel)(upstream, scope).pipe(flatMap3(forever({
+  disableYield: true
+})), catchDone(succeed6)));
+var fromTransform2 = (transform) => {
+  const self = Object.create(SinkProto);
+  self.transform = transform;
+  return self;
+};
+var toChannel = (self) => fromTransform((upstream, scope) => succeed6(flatMap3(self.transform(upstream, scope), done)));
+var drain = /* @__PURE__ */ fromTransform2((upstream) => catchDone(forever(upstream, {
+  disableYield: true
+}), () => endVoid));
+var forEach2 = (f) => forEachArray(forEach((_) => f(_), {
+  discard: true
+}));
+var forEachArray = (f) => fromTransform2((upstream) => upstream.pipe(flatMap3(f), forever({
+  disableYield: true
+}), catchDone(() => endVoid)));
+var unwrap3 = (effect) => fromChannel(unwrap2(map8(effect, toChannel)));
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/internal/rcRef.js
+var TypeId8 = "~effect/RcRef";
+var stateEmpty = {
+  _tag: "Empty"
+};
+var stateClosed = {
+  _tag: "Closed"
+};
+var variance2 = {
+  _A: identity,
+  _E: identity
+};
+
+class RcRefImpl {
+  [TypeId8] = variance2;
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  state = stateEmpty;
+  acquire;
+  context;
+  scope;
+  idleTimeToLive;
+  constructor(acquire, context, scope, idleTimeToLive) {
+    this.acquire = acquire;
+    this.context = context;
+    this.scope = scope;
+    this.idleTimeToLive = idleTimeToLive;
+  }
+}
+var make6 = (options) => withFiber2((fiber) => {
+  const context = fiber.context;
+  const scope = get4(context, Scope);
+  const ref = new RcRefImpl(options.acquire, context, scope, options.idleTimeToLive !== undefined ? fromInputUnsafe(options.idleTimeToLive) : undefined);
+  return as(addFinalizerExit(scope, () => {
+    const state = ref.state;
+    ref.state = stateClosed;
+    if (state._tag === "Acquired")
+      return close(state.scope, void_2);
+    if (state._tag === "Acquiring")
+      return interrupt(state.fiber);
+    return void_3;
+  }), ref);
+});
+var getState = (self, restore) => {
+  switch (self.state._tag) {
+    case "Closed": {
+      return interrupt3;
+    }
+    case "Acquired": {
+      const state = self.state;
+      state.refCount++;
+      return state.fiber ? as(interrupt(state.fiber), state) : succeed6(state);
+    }
+    case "Acquiring": {
+      const state = self.state;
+      state.awaiters++;
+      return awaitAcquiring(self, state, restore);
+    }
+    case "Empty": {
+      const acquiring = {
+        _tag: "Acquiring",
+        fiber: undefined,
+        awaiters: 1,
+        acquired: undefined
+      };
+      self.state = acquiring;
+      const scope = makeUnsafe6();
+      const acquire = provideContext2(self.acquire, add(self.context, Scope, scope)).pipe(flatMap3((value) => {
+        if (self.state !== acquiring) {
+          return interrupt3;
+        }
+        const state = {
+          _tag: "Acquired",
+          value,
+          scope,
+          fiber: undefined,
+          refCount: acquiring.awaiters,
+          invalidated: false
+        };
+        self.state = state;
+        acquiring.acquired = state;
+        return succeed6(state);
+      }), onExit((exit) => {
+        if (isSuccess2(exit))
+          return void_3;
+        if (self.state === acquiring)
+          self.state = stateEmpty;
+        return close(scope, exit);
+      }));
+      acquiring.fiber = runForkWith(getCurrent().context)(acquire);
+      return awaitAcquiring(self, acquiring, restore);
+    }
+  }
+};
+var awaitAcquiring = (self, acquiring, restore) => onExit(restore(join(acquiring.fiber)), (exit) => {
+  const acquired = acquiring.acquired;
+  if (acquired !== undefined) {
+    return isFailure2(exit) ? release(self, acquired) : void_3;
+  }
+  if (--acquiring.awaiters > 0 || self.state !== acquiring)
+    return void_3;
+  self.state = stateEmpty;
+  return interrupt(acquiring.fiber);
+});
+var get2 = (self_) => {
+  const self = self_;
+  return uninterruptibleMask2((restore) => flatMap3(scope2, (scope) => flatMap3(getState(self, restore), (state) => as(addFinalizerExit(scope, () => release(self, state)), state.value))));
+};
+var release = (self, state) => {
+  state.refCount--;
+  if (state.refCount > 0) {
+    return void_3;
+  }
+  const idleTimeToLive = self.idleTimeToLive;
+  if (idleTimeToLive === undefined || state.invalidated) {
+    if (self.state === state) {
+      self.state = stateEmpty;
+    }
+    return close(state.scope, void_2);
+  } else if (!isFinite(idleTimeToLive)) {
+    return void_3;
+  }
+  state.fiber = uninterruptibleMask2((restore) => flatMap3(restore(sleep(idleTimeToLive)), () => {
+    if (self.state === state && state.refCount === 0) {
+      self.state = stateEmpty;
+      return ignoreCause(close(state.scope, void_2), {
+        log: "Unhandled",
+        message: "Unhandled error in RcRef finalizer"
+      });
+    }
+    return void_3;
+  })).pipe(ensuring2(sync2(() => {
+    state.fiber = undefined;
+  })), runForkWith(self.context), runIn(self.scope));
+  return void_3;
+};
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/RcRef.js
+var make10 = make6;
+var get3 = get2;
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Stream.js
+var TypeId9 = "~effect/Stream";
+var isStream = (u) => hasProperty(u, TypeId9);
+var fromChannel2 = fromChannel3;
+var fromPull2 = (pull) => fromChannel2(fromPull(pull));
+var transformPull2 = (self, f) => fromChannel2(fromTransform((_, scope) => flatMap3(toPullScoped(self.channel, scope), (pull) => f(pull, scope))));
+var toChannel2 = (stream) => stream.channel;
+var callback = (f, options) => fromChannel2(callbackArray(f, options));
+var empty2 = /* @__PURE__ */ fromChannel2(empty);
+var make11 = (...values) => fromArray2(values);
+var suspend = (stream) => {
+  const suspended = fromChannel2(suspend4(() => stream().channel));
+  suspendedStreams.set(suspended, stream);
+  return suspended;
+};
+var suspendedStreams = /* @__PURE__ */ new WeakMap;
+var fail2 = (error) => fromChannel2(fail5(error));
+var die4 = (defect) => fromChannel2(die(defect));
+var fromArray2 = (array) => isReadonlyArrayNonEmpty(array) ? fromChannel2(succeed4(array)) : empty2;
+var fromQueue = (queue) => fromChannel2(fromQueueArray(queue));
+var fromPubSub = (pubsub) => fromChannel2(fromPubSubArray(pubsub));
+var fromReadableStream = (options) => fromChannel2(fromReadableStream2(options));
+var unwrap = (effect) => fromChannel2(unwrap2(map8(effect, toChannel2)));
+var map2 = /* @__PURE__ */ dual(2, (self, f) => suspend(() => {
+  let i = 0;
+  return fromChannel2(map7(self.channel, map6((o) => f(o, i++))));
+}));
+var mapEffect2 = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, f, options) => self.channel.pipe(flattenArray, mapEffect(f, options), map7(of), fromChannel2));
+var tap = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, f, options) => mapEffect2(self, (a) => as(f(a), a), options));
+var drainFork = /* @__PURE__ */ dual(2, (self, that) => mergeEffect2(self, runDrain(that)));
+var concat = /* @__PURE__ */ dual(2, (self, that) => {
+  const stream = fromChannel2(flatten2(fromIterator(() => concatChannels(self, that))));
+  concatParts.set(stream, [self, that]);
+  return stream;
+});
+var concatParts = /* @__PURE__ */ new WeakMap;
+function* concatChannels(self, that) {
+  const stack = [that, self];
+  while (stack.length > 0) {
+    const stream = stack.pop();
+    const parts = concatParts.get(stream);
+    if (parts !== undefined) {
+      stack.push(parts[1], parts[0]);
+      continue;
+    }
+    const evaluate = suspendedStreams.get(stream);
+    if (evaluate === undefined) {
+      yield stream.channel;
+      continue;
+    }
+    try {
+      stack.push(evaluate());
+    } catch (defect) {
+      stack.push(die4(defect));
+    }
+    yield empty;
+  }
+}
+var merge2 = /* @__PURE__ */ dual((args) => isStream(args[0]) && isStream(args[1]), (self, that, options) => fromChannel2(merge(toChannel2(self), toChannel2(that), options)));
+var mergeEffect2 = /* @__PURE__ */ dual(2, (self, effect) => self.channel.pipe(mergeEffect(effect), fromChannel2));
+var filter = /* @__PURE__ */ dual(2, (self, predicate) => fromChannel2(filterArray(toChannel2(self), predicate)));
+var catchCause = /* @__PURE__ */ dual(2, (self, f) => self.channel.pipe(catchCause3((cause) => f(cause).channel), fromChannel2));
+var tapError = /* @__PURE__ */ dual(2, (self, f) => self.channel.pipe(tapError3(f), fromChannel2));
+var mapError = /* @__PURE__ */ dual(2, (self, f) => fromChannel2(mapError3(self.channel, f)));
+var transduce = /* @__PURE__ */ dual(2, (self, sink) => transformPull2(self, (upstream, scope) => sync2(() => {
+  let done2;
+  let leftover;
+  const upstreamWithLeftover = suspend3(() => {
+    if (leftover !== undefined) {
+      const chunk = leftover;
+      leftover = undefined;
+      return succeed6(chunk);
+    }
+    return upstream;
+  }).pipe(catch_((error) => {
+    done2 = fail4(error);
+    return done();
+  }));
+  const pull = map8(suspend3(() => sink.transform(upstreamWithLeftover, scope)), ([value, leftover_]) => {
+    leftover = leftover_;
+    return of(value);
+  });
+  return suspend3(() => done2 ? done2 : pull);
+})));
+var decodeText = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, options) => self.channel.pipe(pipeTo(decodeText2(options?.encoding)), fromChannel2));
+var encodeText = (self) => suspend(() => {
+  const encoder = new TextEncoder;
+  return map2(self, (chunk) => encoder.encode(chunk));
+});
+var splitLines = (self) => self.channel.pipe(pipeTo(splitLines2()), fromChannel2);
+var interruptWhen = /* @__PURE__ */ dual(2, (self, effect) => fromChannel2(interruptWhen2(self.channel, effect)));
+var ensuring = /* @__PURE__ */ dual(2, (self, finalizer) => fromChannel2(ensuring3(self.channel, finalizer)));
+var provideContext = /* @__PURE__ */ dual(2, (self, context) => fromChannel2(provideContext3(self.channel, context)));
+var run = /* @__PURE__ */ dual(2, (self, sink) => scopedWith((scope) => toPullScoped(self.channel, scope).pipe(flatMap3((upstream) => runSink(sink, upstream, scope)), map8(([a]) => a))));
+var runSink = (sink, upstream, scope) => restoreUpstreamFailure(sink.transform(upstreamFailureToDefect(upstream), scope));
+var runCollect = (self) => runFold2(self.channel, () => [], (acc, chunk) => {
+  for (let i = 0;i < chunk.length; i++) {
+    acc.push(chunk[i]);
+  }
+  return acc;
+});
+var runFold = /* @__PURE__ */ dual(3, (self, initial, f) => runFold2(self.channel, initial, (acc, arr) => {
+  for (let i = 0;i < arr.length; i++) {
+    acc = f(acc, arr[i]);
+  }
+  return acc;
+}));
+var runHead = (self) => map8(runHead2(self.channel), map4(getUnsafe2(0)));
+var runForEach = /* @__PURE__ */ dual(2, (self, f) => runForEach2(self.channel, (arr) => {
+  let i = 0;
+  return whileLoop({
+    while: () => i < arr.length,
+    body: () => f(arr[i++]),
+    step: constVoid
+  });
+}));
+var runDrain = (self) => runDrain2(self.channel);
+var mkString = (self) => runFold2(self.channel, () => "", (acc, chunk) => acc + chunk.join(""));
+var mkArrayBuffer = (self) => map8(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 = makeUnsafe2(false);
+  const signal = options?.signal;
+  const onAbort = () => fiber.interruptUnsafe();
+  return new ReadableStream({
+    start(controller) {
+      fiber = runFork(provideContext2(runForEach2(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 runPromise(asVoid(interrupt(fiber)));
+    }
+  }, options?.strategy);
+});
+var toReadableStreamEffect = /* @__PURE__ */ dual((args) => isStream(args[0]), (self, options) => map8(context(), (context) => toReadableStreamWith(self, context, options)));
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/FileSystem.js
+var TypeId10 = "~effect/FileSystem";
+var FileSystem = /* @__PURE__ */ Service2("effect/FileSystem");
+var make12 = (impl) => FileSystem.of({
+  ...impl,
+  [TypeId10]: TypeId10,
+  glob: make2(impl),
+  exists: (path) => pipe(impl.access(path), as(true), catchTag("PlatformError", (e) => e.reason._tag === "NotFound" ? succeed6(false) : fail7(e))),
+  readFileString: (path, encoding) => flatMap3(impl.readFile(path), (_) => try_2({
+    try: () => new TextDecoder(encoding).decode(_),
+    catch: (cause) => badArgument({
+      module: "FileSystem",
+      method: "readFileString",
+      description: "invalid encoding",
+      cause
+    })
+  })),
+  stream: fnUntraced(function* (path, options) {
+    const file = yield* impl.open(path, {
+      flag: "r"
+    });
+    const offset = options?.offset === undefined ? undefined : fromInputUnsafe2(options.offset);
+    if (offset) {
+      yield* file.seek(offset, "start");
+    }
+    const bytesToRead = options?.bytesToRead === undefined ? undefined : fromInputUnsafe2(options.bytesToRead);
+    let totalBytesRead = BigInt(0);
+    const chunkSize = Number(BigInt(options?.chunkSize ?? 64 * 1024));
+    const readChunk = file.readAlloc(chunkSize);
+    return fromPull2(succeed6(flatMap3(suspend3(() => {
+      if (bytesToRead !== undefined && bytesToRead <= totalBytesRead) {
+        return done();
+      }
+      return bytesToRead !== undefined && bytesToRead - totalBytesRead < chunkSize ? file.readAlloc(Number(bytesToRead - totalBytesRead)) : readChunk;
+    }), match({
+      onNone: () => done(),
+      onSome: (buf) => {
+        totalBytesRead += BigInt(buf.length);
+        return succeed6(of(buf));
+      }
+    }))));
+  }, unwrap),
+  sink: (path, options) => pipe(impl.open(path, {
+    ...options,
+    flag: options?.flag ?? "w"
+  }), map8((file) => forEach2((_) => file.writeAll(_))), unwrap3),
+  writeFileString: (path, data, options) => flatMap3(try_2({
+    try: () => new TextEncoder().encode(data),
+    catch: (cause) => badArgument({
+      module: "FileSystem",
+      method: "writeFileString",
+      description: "could not encode string",
+      cause
+    })
+  }), (_) => impl.writeFile(path, _, options))
+});
+var FileTypeId = "~effect/FileSystem/File";
+class WatchBackend extends (/* @__PURE__ */ Service2()("effect/FileSystem/WatchBackend")) {
+}
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Path.js
+var TypeId11 = "~effect/Path";
+var Path = /* @__PURE__ */ Service2("effect/Path");
+var make13 = (impl) => Path.of({
+  ...impl,
+  [TypeId11]: TypeId11,
+  resolveWithin(root, input) {
+    if (impl.parse(input).root !== "")
+      return none();
+    const base = impl.resolve(root);
+    const candidate = impl.resolve(base, input);
+    const relative = impl.relative(base, candidate);
+    return relative === ".." || relative.startsWith(`..${impl.sep}`) || impl.isAbsolute(relative) ? none() : some(candidate);
+  }
+});
+
+// packages/core/src/embedded-files.ts
+function embeddedFile(files, name) {
+  const pattern = new RegExp(`^${name}-[a-z0-9]+\\.$`);
+  return files.find((file) => ("name" in file) && pattern.test(String(file.name)));
+}
+var extractEmbeddedFile = fnUntraced(function* (directory, file, name) {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const target = path.join(directory, file.name.slice(0, -1), name);
+  const existing = yield* fs.stat(target).pipe(option2);
+  if (isSome(existing) && Number(existing.value.size) === file.size)
+    return target;
+  yield* fs.makeDirectory(path.dirname(target), { recursive: true });
+  const written = path.join(yield* fs.makeTempDirectoryScoped({ directory: path.dirname(target) }), name);
+  yield* fs.writeFile(written, new Uint8Array(yield* promise(() => file.arrayBuffer())));
+  yield* fs.chmod(written, 493);
+  yield* fs.rename(written, target);
+  return target;
+}, scoped);
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/ConfigProvider.js
+function makeValue(value) {
+  return {
+    _tag: "Value",
+    value
+  };
+}
+function makeRecord(keys, value) {
+  return {
+    _tag: "Record",
+    keys,
+    value
+  };
+}
+function makeArray(length, value) {
+  return {
+    _tag: "Array",
+    length,
+    value
+  };
+}
+var ConfigProvider = /* @__PURE__ */ Reference("effect/ConfigProvider", {
+  defaultValue: () => fromEnv()
+});
+var Proto = {
+  ...PipeInspectableProto,
+  toJSON() {
+    return {
+      _id: "ConfigProvider"
+    };
+  }
+};
+var identityPath = (path) => path;
+function makeProvider(load, mapInput) {
+  const self = Object.create(Proto);
+  self.load = load;
+  self.mapInput = mapInput;
+  return self;
+}
+function makeSource(get, transform) {
+  return makeProvider((path) => get(transform(path)), (f) => makeSource(get, (path) => f(transform(path))));
+}
+function make7(get) {
+  return makeSource(get, identityPath);
+}
+function emptyStringAsMissing(value, preserveEmptyStrings) {
+  return value === "" && !preserveEmptyStrings ? undefined : value;
+}
+function fromEnvRecord(env, options) {
+  const preserveEmptyStrings = options?.preserveEmptyStrings === true;
+  const trie = buildEnvTrie(env);
+  return make7((path) => succeed6(nodeAtEnv(trie, env, path, preserveEmptyStrings)));
+}
+function fromEnv(options) {
+  const env = options?.env ?? {
+    ...globalThis.process?.env,
+    ...import.meta?.env
+  };
+  return fromEnvRecord(env, {
+    preserveEmptyStrings: options?.preserveEmptyStrings
+  });
+}
+function buildEnvTrie(env) {
+  const trie = {};
+  for (const [name, value] of Object.entries(env)) {
+    if (value === undefined)
+      continue;
+    const segments = name.split("_");
+    let node = trie;
+    for (const seg of segments) {
+      const children = node.children ??= Object.create(null);
+      node = children[seg] ??= {};
+    }
+  }
+  return trie;
+}
+function nodeAtEnv(trie, env, path, preserveEmptyStrings) {
+  const key = path.map(String).join("_");
+  const leafValue = emptyStringAsMissing(Object.hasOwn(env, key) ? env[key] : undefined, preserveEmptyStrings);
+  const trieNode = trieNodeAt(trie, path);
+  const children = trieNode?.children ? Object.keys(trieNode.children) : [];
+  if (children.length === 0) {
+    return leafValue === undefined ? undefined : makeValue(leafValue);
+  }
+  const allNumeric = children.every(isCanonicalArrayIndex);
+  if (allNumeric) {
+    const length = Math.max(...children.map((k) => parseInt(k, 10))) + 1;
+    return makeArray(length, leafValue);
+  }
+  return makeRecord(new Set(children), leafValue);
+}
+function trieNodeAt(root, path) {
+  if (path.length === 0)
+    return root;
+  let node = root;
+  for (const seg of path) {
+    node = node?.children?.[String(seg)];
+    if (!node)
+      return;
+  }
+  return node;
+}
+
+// node_modules/.bun/effect@4.1.2/node_modules/effect/dist/Config.js
+var TypeId12 = "~effect/Config";
+class ConfigError {
+  _tag = "ConfigError";
+  name = "ConfigError";
+  cause;
+  constructor(cause) {
+    this.cause = cause;
+  }
+  get message() {
+    return this.cause.toString();
+  }
+  toString() {
+    return `ConfigError(${this.message})`;
+  }
+}
+var Proto2 = {
+  .../* @__PURE__ */ Prototype({
+    label: "Config",
+    evaluate(fiber) {
+      return this.parse(fiber.getRef(ConfigProvider));
+    }
+  }),
+  [TypeId12]: TypeId12,
+  toJSON() {
+    return {
+      _id: "Config"
+    };
+  }
+};
+function make14(evaluator) {
+  const self = Object.create(Proto2);
+  self.evaluator = evaluator;
+  self.parse = (provider) => flatMapEager(evaluator(provider, []), fromResult);
+  return self;
+}
+var evaluateAt = (self, provider, pathPrefix) => self.evaluator(provider, pathPrefix);
+var map3 = /* @__PURE__ */ dual(2, (self, f) => {
+  return make14((provider, pathPrefix) => map8(evaluateAt(self, provider, pathPrefix), map5(f)));
+});
+function all(arg) {
+  const configs = globalThis.Array.isArray(arg) ? arg : (Symbol.iterator in arg) ? [...arg] : arg;
+  return make14((provider, pathPrefix) => globalThis.Array.isArray(configs) ? mapEager(all3(configs.map((config) => evaluateAt(config, provider, pathPrefix))), all2) : mapEager(all3(map(configs, (config) => evaluateAt(config, provider, pathPrefix))), all2));
+}
+var withDefault = /* @__PURE__ */ dual(2, (self, defaultValue) => {
+  return make14((provider, pathPrefix) => mapEager(evaluateAt(self, provider, pathPrefix), (resolution) => isFailure(resolution) ? succeed(defaultValue) : resolution));
+});
+var option = (self) => self.pipe(map3(some), withDefault(none()));
+var isSourceError = (u) => isTagged(u, "SourceError");
+var cursorToString = () => "<configuration>";
+var mapReasons = (f) => (self) => catchCause2(self, (cause) => failCause3(fromReasons(cause.reasons.map(f))));
+var loadCursor = (provider, path) => provider.load(path).pipe(mapReasons((reason) => isFailReason(reason) ? makeDieReason(reason.error).annotate(reasonAnnotations(reason)) : reason), mapEager((node) => ({
+  provider,
+  path,
+  node,
+  toString: cursorToString
+})));
+var loadChildCursor = (cursor, segment) => loadCursor(cursor.provider, [...cursor.path, segment]);
+var decodeFromCursor = (ast, decode) => decodeTo(unknown, ast, new Transformation(transformEffect((input) => decode(input)), passthrough()));
+var isScalarInput = (ast) => {
+  switch (ast._tag) {
+    case "Union":
+      return ast.types.every(isScalarInput);
+    case "Objects":
+    case "Arrays":
+    case "Suspend":
+      return false;
+    default:
+      return true;
+  }
+};
+var hasProviderInput = (ast, node) => {
+  switch (ast._tag) {
+    case "Objects":
+      return node?._tag === "Record";
+    case "Arrays":
+      return node?._tag === "Array";
+    case "Union":
+      return ast.types.some((ast) => hasProviderInput(ast, node));
+    case "Suspend":
+      return hasProviderInput(ast.thunk(), node);
+    default:
+      return node?.value !== undefined;
+  }
+};
+var toConfigCursorAST = /* @__PURE__ */ memoize((root) => {
+  const seen = new WeakSet;
+  const recur = applyToSelfOrLastLinkEncoding((ast) => {
+    seen.add(ast);
+    switch (ast._tag) {
+      case "Objects": {
+        const materialize = fnUntraced(function* (cursor) {
+          if (cursor.node?._tag !== "Record") {
+            return;
+          }
+          const node = cursor.node;
+          const keys = new Set;
+          for (const property of ast.propertySignatures) {
+            if (typeof property.name === "string")
+              keys.add(property.name);
+          }
+          if (ast.indexSignatures.length > 0) {
+            const input = {};
+            for (const key of node.keys) {
+              assignProperty(input, key, undefined);
+            }
+            for (const is of ast.indexSignatures) {
+              for (const key of getIndexSignatureKeys(input, is.parameter)) {
+                if (typeof key === "string")
+                  keys.add(key);
+              }
+            }
+          }
+          const out = {};
+          for (const key of keys) {
+            const child = yield* loadChildCursor(cursor, key);
+            if (child.node !== undefined)
+              assignProperty(out, key, child);
+          }
+          return out;
+        });
+        return decodeFromCursor(ast.recur(recur, (ast) => ast), materialize);
+      }
+      case "Arrays": {
+        const materialize = fnUntraced(function* (cursor) {
+          if (cursor.node?._tag !== "Array") {
+            return;
+          }
+          const out = [];
+          for (let i = 0;i < cursor.node.length; i++) {
+            out.push(yield* loadChildCursor(cursor, i));
+          }
+          return out;
+        });
+        return decodeFromCursor(ast.recur(recur), materialize);
+      }
+      case "Union":
+        for (const member of ast.types) {
+          recur(member);
+        }
+        if (!isScalarInput(ast))
+          return ast.recur(recur);
+        break;
+      case "Suspend": {
+        const target = ast.thunk();
+        if (!seen.has(target))
+          recur(target);
+        return ast.recur(recur);
+      }
+      case "Declaration":
+      case "Any":
+        throw new globalThis.Error("Config.schema does not support opaque StringTree encodings", {
+          cause: ast
+        });
+    }
+    return decodeFromCursor(ast, (cursor) => succeed6(cursor.node?.value));
+  });
+  return recur(root);
+});
+function schema(codec, path) {
+  const codecStringTree = toCodecStringTree(codec);
+  const encodedAst = toEncoded(codecStringTree.ast);
+  const decodeCursor = decodeUnknownEffect(make18(toConfigCursorAST(codecStringTree.ast)));
+  const localPath = typeof path === "string" ? [path] : path ?? [];
+  return make14((provider, pathPrefix) => {
+    const fullPath = [...pathPrefix, ...localPath];
+    return loadCursor(provider, fullPath).pipe(flatMapEager((cursor) => decodeCursor(cursor).pipe(mapEager(succeed), catchEager((issue) => {
+      const error = new ConfigError(new SchemaError(fullPath.length > 0 ? new Pointer(fullPath, issue) : issue));
+      return hasProviderInput(encodedAst, cursor.node) ? fail7(error) : succeed6(fail3(error));
+    }))), mapReasons((reason) => isDieReason(reason) && isSourceError(reason.defect) ? makeFailReason(new ConfigError(reason.defect)).annotate(reasonAnnotations(reason)) : reason));
+  });
+}
+function String2(name) {
+  return schema(String4, name);
+}
+
+// packages/agent-runtime/src/srt-sandbox.ts
+import { homedir } from "os";
+import { fileURLToPath } from "url";
+
+// packages/agent-runtime/src/env.ts
+var optionalEnv = (name) => gen(function* () {
+  const value = getOrUndefined(yield* option(String2(name)))?.trim();
+  return value === undefined || value.length === 0 ? undefined : value;
+}).pipe(orElseSucceed(() => {
+  return;
+}));
+
+// packages/agent-runtime/src/srt-sandbox.ts
+var harnessesUnsupportedInSrt2 = ["codex"];
+var compiled2 = import.meta.url.startsWith("file:///$bunfs/");
+var pinnedSrtCommand2 = () => compiled2 ? [process.execPath, "srt"] : [process.execPath, fileURLToPath(import.meta.resolve("@anthropic-ai/sandbox-runtime/dist/cli.js"))];
+var pinnedSrtStepCommand2 = () => compiled2 ? [process.execPath, "srt-step"] : [process.execPath, fileURLToPath(new URL("./srt-step.main.ts", import.meta.url))];
+var srtPackageDir = () => fileURLToPath(new URL("../", import.meta.resolve("@anthropic-ai/sandbox-runtime/dist/cli.js")));
+var runSrtCli2 = () => import("@anthropic-ai/sandbox-runtime/dist/cli.js");
+var embeddedApplySeccomp = gen(function* () {
+  const file = compiled2 && process.platform === "linux" ? embeddedFile(Bun.embeddedFiles, "apply-seccomp") : undefined;
+  if (file === undefined)
+    return;
+  const path = yield* Path;
+  const cacheHome = yield* String2("XDG_CACHE_HOME").pipe(withDefault(""));
+  return yield* extractEmbeddedFile(path.join(cacheHome === "" ? path.join(homedir(), ".cache") : cacheHome, "kitman"), file, "apply-seccomp");
+}).pipe(orDie);
+var globCharacters = /[*?[\]{}]/;
+var readAllowEntry = (path) => globCharacters.test(path) ? { path, literal: true } : path;
+var srtSettings2 = (policy, ownFiles = [], unixSockets = []) => policy.network === "open" ? undefined : {
+  network: {
+    allowedDomains: [...policy.network.hosts],
+    deniedDomains: [],
+    strictAllowlist: true,
+    ...unixSockets.length === 0 ? undefined : { allowUnixSockets: [...unixSockets] }
+  },
+  filesystem: {
+    denyRead: [...policy.readDeniedPaths],
+    allowRead: [...policy.readAllowedPaths, ...ownFiles].map(readAllowEntry),
+    allowWrite: [...policy.writablePaths],
+    denyWrite: []
+  }
+};
+var srtCacheEnvironment2 = (dir) => ({
+  XDG_CACHE_HOME: dir,
+  npm_config_cache: `${dir}/npm`,
+  BUN_INSTALL_CACHE_DIR: `${dir}/bun`
+});
+var srtInheritedEnv2 = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "TMPDIR",
+  "LANG",
+  "LC_ALL",
+  "LC_CTYPE",
+  "TZ"
+];
+var inheritedEnvironment2 = (names) => map8(forEach(names, (name) => map8(optionalEnv(name), (value) => value === undefined ? [] : [[name, value]])), (entries) => Object.fromEntries(entries.flat()));
+var shellName = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var withOnlyEnvironment2 = (names, argv) => [
+  "sh",
+  "-c",
+  `exec env -i ${[...new Set(names)].flatMap((name) => shellName.test(name) ? [`\${${name}+"${name}=$${name}"}`] : []).join(" ")} "$@"`,
+  "sh",
+  ...argv
+];
+var linkTarget = (fs, path) => {
+  const expanded = path === "~" || path.startsWith("~/") ? `${homedir()}${path.slice(1)}` : path;
+  return fs.readLink(expanded).pipe(andThen2(fs.realPath(expanded)), orElseSucceed(() => path));
+};
+var writeSrtSettings2 = (policy, unixSockets) => gen(function* () {
+  const fs = yield* FileSystem;
+  const path = yield* Path;
+  const applyPath = yield* embeddedApplySeccomp;
+  const seccomp = applyPath ?? (compiled2 ? undefined : path.join(srtPackageDir(), "vendor"));
+  const readAllowedPaths = yield* forEach(policy.readAllowedPaths, (allowed) => linkTarget(fs, allowed));
+  const settings = srtSettings2({ ...policy, readAllowedPaths }, seccomp === undefined ? [] : [seccomp], unixSockets);
+  if (settings === undefined)
+    return yield* die3(new Error("srt cannot run a Step with an open network"));
+  const dir = yield* fs.makeTempDirectoryScoped({ prefix: "kitman-srt-" });
+  const settingsFile = path.join(dir, "srt-settings.json");
+  yield* fs.writeFileString(settingsFile, encodeUnknownJsonStringSync(applyPath === undefined ? settings : { ...settings, seccomp: { applyPath } }));
+  return { dir, settingsFile };
+});
+var srtStepArgv2 = (srtStepCommand, settingsFile, registryFile, argv) => [...srtStepCommand, "--settings", settingsFile, "--secrets", registryFile, "--", ...argv];
+var srtArgv2 = (srtCommand, settingsFile, argv) => [
+  ...srtCommand,
+  "--settings",
+  settingsFile,
+  "--",
+  ...argv
+];
+
+export { map, makeEquivalence, bytes, join, interrupt, getCurrent, BadArgument, systemError, badArgument, makeUnsafe2, make8, unbounded, publishUnsafe, make9, bounded, sliding, unbounded2, offer, offerUnsafe, offerAll, fail, failCause, failCauseUnsafe, end, endUnsafe, shutdownUnsafe, take, poll, makeUnsafe3, fromTransform, mapDone, isSink, fromChannel, drain, make10, get3, isStream, fromChannel2, callback, empty2, make11, suspend, fail2, fromQueue, fromPubSub, fromReadableStream, unwrap, map2, tap, drainFork, concat, merge2, filter, catchCause, tapError, mapError, transduce, decodeText, encodeText, splitLines, interruptWhen, ensuring, provideContext, run, runCollect, runFold, runHead, runForEach, runDrain, mkString, mkArrayBuffer, toReadableStreamEffect, FileSystem, make12, FileTypeId, WatchBackend, Path, make13, embeddedFile, extractEmbeddedFile, map3, all, withDefault, option, String2, optionalEnv, harnessesUnsupportedInSrt2, compiled2, pinnedSrtCommand2, pinnedSrtStepCommand2, runSrtCli2, srtSettings2, srtCacheEnvironment2, srtInheritedEnv2, inheritedEnvironment2, withOnlyEnvironment2, writeSrtSettings2, srtStepArgv2, srtArgv2 };