@effect/language-service 0.48.0 → 0.49.0

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -65,6 +65,8 @@ var dual = function(arity, body) {
 };
 var identity = (a) => a;
 var constant = (value) => () => value;
+var constTrue = /* @__PURE__ */ constant(true);
+var constFalse = /* @__PURE__ */ constant(false);
 var constUndefined = /* @__PURE__ */ constant(void 0);
 function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   switch (arguments.length) {
@@ -96,7 +98,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Equivalence.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Equivalence.js
 var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
 var array = (item) => make((self, that) => {
   if (self.length !== that.length) {
@@ -111,7 +113,7 @@ var array = (item) => make((self, that) => {
   return true;
 });
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/GlobalValue.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/GlobalValue.js
 var globalStoreId = `effect/GlobalValue`;
 var globalStore;
 var globalValue = (id, compute) => {
@@ -125,7 +127,7 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Predicate.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Predicate.js
 var isString = (input) => typeof input === "string";
 var isNumber = (input) => typeof input === "number";
 var isBoolean = (input) => typeof input === "boolean";
@@ -133,9 +135,13 @@ var isFunction2 = isFunction;
 var isRecordOrArray = (input) => typeof input === "object" && input !== null;
 var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
 var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
+var isTagged = /* @__PURE__ */ dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/errors.js
+var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var GenKindImpl = class {
   value;
@@ -257,7 +263,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Hash.js
 var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
 var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
 var hash = (self) => {
@@ -324,14 +330,21 @@ var string = (str) => {
   }
   return optimize(h);
 };
-var structureKeys = (o, keys2) => {
+var structureKeys = (o, keys3) => {
   let h = 12289;
-  for (let i = 0; i < keys2.length; i++) {
-    h ^= pipe(string(keys2[i]), combine(hash(o[keys2[i]])));
+  for (let i = 0; i < keys3.length; i++) {
+    h ^= pipe(string(keys3[i]), combine(hash(o[keys3[i]])));
   }
   return optimize(h);
 };
 var structure = (o) => structureKeys(o, Object.keys(o));
+var array2 = (arr) => {
+  let h = 6151;
+  for (let i = 0; i < arr.length; i++) {
+    h = pipe(h, combine(hash(arr[i])));
+  }
+  return optimize(h);
+};
 var cached = function() {
   if (arguments.length === 1) {
     const self2 = arguments[0];
@@ -356,7 +369,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -410,7 +423,7 @@ function compareBoth(self, that) {
 var isEqual = (u) => hasProperty(u, symbol2);
 var equivalence = () => equals;
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -450,6 +463,12 @@ var Class = class {
     return format(this.toJSON());
   }
 };
+var stringifyCircular = (obj, whitespace) => {
+  let cache = [];
+  const retVal = JSON.stringify(obj, (_key, value) => typeof value === "object" && value !== null ? cache.includes(value) ? void 0 : cache.push(value) && (redactableState.fiberRefs !== void 0 && isRedactable(value) ? value[symbolRedactable](redactableState.fiberRefs) : value) : value, whitespace);
+  cache = void 0;
+  return retVal;
+};
 var symbolRedactable = /* @__PURE__ */ Symbol.for("effect/Inspectable/Redactable");
 var isRedactable = (u) => typeof u === "object" && u !== null && symbolRedactable in u;
 var redactableState = /* @__PURE__ */ globalValue("effect/Inspectable/redactableState", () => ({
@@ -462,7 +481,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args2) => {
   switch (args2.length) {
     case 0:
@@ -495,14 +514,16 @@ var pipeArguments = (self, args2) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
+var OP_FAILURE = "Failure";
+var OP_WITH_RUNTIME = "WithRuntime";
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/version.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/version.js
 var moduleVersion = "3.18.4";
 var getCurrentVersion = () => moduleVersion;
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/effectable.js
 var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
 var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
 var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
@@ -589,7 +610,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -647,7 +668,7 @@ var some = (value) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -709,7 +730,7 @@ var right = (right3) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Either.js
 var right2 = right;
 var left2 = left;
 var isLeft2 = isLeft;
@@ -717,14 +738,16 @@ var isRight2 = isRight;
 var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
 var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/array.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Order.js
 var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
 var string2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
+var number2 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
+var mapInput = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
 var some2 = some;
 var isNone2 = isNone;
@@ -735,7 +758,7 @@ var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nu
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
 var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Record.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Record.js
 var map3 = /* @__PURE__ */ dual(2, (self, f) => {
   const out = {
     ...self
@@ -747,7 +770,7 @@ var map3 = /* @__PURE__ */ dual(2, (self, f) => {
 });
 var keys = (self) => Object.keys(self);
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Array.js
 var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
 var append = /* @__PURE__ */ dual(2, (self, last) => [...self, last]);
 var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
@@ -770,6 +793,7 @@ var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
 var head = /* @__PURE__ */ get(0);
 var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
 var tailNonEmpty = (self) => self.slice(1);
+var reverse = (self) => Array.from(self).reverse();
 var sort = /* @__PURE__ */ dual(2, (self, O) => {
   const out = Array.from(self);
   out.sort(O);
@@ -785,8 +809,8 @@ var containsWith = (isEquivalent) => dual(2, (self, a) => {
 });
 var _equivalence = /* @__PURE__ */ equivalence();
 var intersectionWith = (isEquivalent) => {
-  const has = containsWith(isEquivalent);
-  return dual(2, (self, that) => fromIterable(self).filter((a) => has(that, a)));
+  const has3 = containsWith(isEquivalent);
+  return dual(2, (self, that) => fromIterable(self).filter((a) => has3(that, a)));
 };
 var intersection = /* @__PURE__ */ intersectionWith(_equivalence);
 var empty = () => [];
@@ -828,6 +852,7 @@ var partition = /* @__PURE__ */ dual(2, (self, predicate) => {
   }
   return [left3, right3];
 });
+var reduce = /* @__PURE__ */ dual(3, (self, b, f) => fromIterable(self).reduce((b2, a, i) => f(b2, a, i), b));
 var every = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
 var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   const input = fromIterable(self);
@@ -1917,10 +1942,10 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
     const sectionOverrides = {};
     const skippedRules = [];
     const regex = /@effect-diagnostics(-next-line)?((?:\s[a-zA-Z0-9/]+:(?:off|warning|error|message|suggestion|skip-file))+)?/gm;
-    let match2;
-    while ((match2 = regex.exec(sourceFile.text)) !== null) {
-      const nextLineCaptureGroup = match2[1];
-      const rulesCaptureGroup = match2[2];
+    let match3;
+    while ((match3 = regex.exec(sourceFile.text)) !== null) {
+      const nextLineCaptureGroup = match3[1];
+      const rulesCaptureGroup = match3[2];
       if (rulesCaptureGroup) {
         const trimmedRuleString = rulesCaptureGroup.trim();
         if (trimmedRuleString) {
@@ -1932,7 +1957,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               if (ruleLevel === "skip-file") skippedRules.push(ruleName);
               const isOverrideNextLine = nextLineCaptureGroup && nextLineCaptureGroup.trim().toLowerCase() === "-next-line";
               if (isOverrideNextLine) {
-                const foundNode = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, match2.index);
+                const foundNode = tsUtils.findNodeWithLeadingCommentAtPosition(sourceFile, match3.index);
                 if (foundNode) {
                   lineOverrides[ruleName] = lineOverrides[ruleName] || [];
                   lineOverrides[ruleName].unshift({
@@ -1945,7 +1970,7 @@ var createDiagnosticExecutor = fn("LSP.createCommentDirectivesProcessor")(
               } else {
                 sectionOverrides[ruleName] = sectionOverrides[ruleName] || [];
                 sectionOverrides[ruleName].unshift({
-                  pos: match2.index,
+                  pos: match3.index,
                   level: ruleLevel
                 });
               }
@@ -2088,9 +2113,9 @@ var getCodegensForSourceFile = fn("LSP.getApplicableCodegens")(function* (codege
   const tsUtils = yield* service(TypeScriptUtils);
   const result = [];
   const regex = /@effect-codegens((?:\s[a-zA-Z0-9]+(?::(?:[a-zA-Z0-9]+))?)+)+/gmid;
-  let match2;
-  while ((match2 = regex.exec(sourceFile.text)) !== null) {
-    const pos = match2.indices?.[0]?.[0];
+  let match3;
+  while ((match3 = regex.exec(sourceFile.text)) !== null) {
+    const pos = match3.indices?.[0]?.[0];
     if (!pos) continue;
     const commentRange = tsUtils.getCommentAtPosition(sourceFile, pos);
     if (!commentRange) continue;
@@ -3994,9 +4019,9 @@ var effectCodegensComment = createCompletion({
   apply: fn("effectCodegensComment")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const sourceText = sourceFile.text;
-    const match2 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
-    if (match2 && match2.indices) {
-      const lastIndex = match2.indices[2][0];
+    const match3 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
+    if (match3 && match3.indices) {
+      const lastIndex = match3.indices[2][0];
       const replacementSpan = {
         start: lastIndex,
         length: Math.max(0, position - lastIndex)
@@ -4048,40 +4073,2270 @@ var effectDataClasses = createCompletion({
   })
 });
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/encoding/common.js
-var encoder = /* @__PURE__ */ new TextEncoder();
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Chunk.js
+var TypeId3 = /* @__PURE__ */ Symbol.for("effect/Chunk");
+function copy(src, srcPos, dest, destPos, len) {
+  for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
+    dest[destPos + i - srcPos] = src[i];
+  }
+  return dest;
+}
+var emptyArray = [];
+var getEquivalence = (isEquivalent) => make((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet2(that, i))));
+var _equivalence2 = /* @__PURE__ */ getEquivalence(equals);
+var ChunkProto = {
+  [TypeId3]: {
+    _A: (_) => _
+  },
+  toString() {
+    return format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "Chunk",
+      values: toReadonlyArray(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  [symbol2](that) {
+    return isChunk(that) && _equivalence2(this, that);
+  },
+  [symbol]() {
+    return cached(this, array2(toReadonlyArray(this)));
+  },
+  [Symbol.iterator]() {
+    switch (this.backing._tag) {
+      case "IArray": {
+        return this.backing.array[Symbol.iterator]();
+      }
+      case "IEmpty": {
+        return emptyArray[Symbol.iterator]();
+      }
+      default: {
+        return toReadonlyArray(this)[Symbol.iterator]();
+      }
+    }
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var makeChunk = (backing) => {
+  const chunk = Object.create(ChunkProto);
+  chunk.backing = backing;
+  switch (backing._tag) {
+    case "IEmpty": {
+      chunk.length = 0;
+      chunk.depth = 0;
+      chunk.left = chunk;
+      chunk.right = chunk;
+      break;
+    }
+    case "IConcat": {
+      chunk.length = backing.left.length + backing.right.length;
+      chunk.depth = 1 + Math.max(backing.left.depth, backing.right.depth);
+      chunk.left = backing.left;
+      chunk.right = backing.right;
+      break;
+    }
+    case "IArray": {
+      chunk.length = backing.array.length;
+      chunk.depth = 0;
+      chunk.left = _empty;
+      chunk.right = _empty;
+      break;
+    }
+    case "ISingleton": {
+      chunk.length = 1;
+      chunk.depth = 0;
+      chunk.left = _empty;
+      chunk.right = _empty;
+      break;
+    }
+    case "ISlice": {
+      chunk.length = backing.length;
+      chunk.depth = backing.chunk.depth + 1;
+      chunk.left = _empty;
+      chunk.right = _empty;
+      break;
+    }
+  }
+  return chunk;
+};
+var isChunk = (u) => hasProperty(u, TypeId3);
+var _empty = /* @__PURE__ */ makeChunk({
+  _tag: "IEmpty"
+});
+var empty2 = () => _empty;
+var make4 = (...as) => unsafeFromNonEmptyArray(as);
+var of = (a) => makeChunk({
+  _tag: "ISingleton",
+  a
+});
+var fromIterable2 = (self) => isChunk(self) ? self : unsafeFromArray(fromIterable(self));
+var copyToArray = (self, array3, initial) => {
+  switch (self.backing._tag) {
+    case "IArray": {
+      copy(self.backing.array, 0, array3, initial, self.length);
+      break;
+    }
+    case "IConcat": {
+      copyToArray(self.left, array3, initial);
+      copyToArray(self.right, array3, initial + self.left.length);
+      break;
+    }
+    case "ISingleton": {
+      array3[initial] = self.backing.a;
+      break;
+    }
+    case "ISlice": {
+      let i = 0;
+      let j = initial;
+      while (i < self.length) {
+        array3[j] = unsafeGet2(self, i);
+        i += 1;
+        j += 1;
+      }
+      break;
+    }
+  }
+};
+var toReadonlyArray_ = (self) => {
+  switch (self.backing._tag) {
+    case "IEmpty": {
+      return emptyArray;
+    }
+    case "IArray": {
+      return self.backing.array;
+    }
+    default: {
+      const arr = new Array(self.length);
+      copyToArray(self, arr, 0);
+      self.backing = {
+        _tag: "IArray",
+        array: arr
+      };
+      self.left = _empty;
+      self.right = _empty;
+      self.depth = 0;
+      return arr;
+    }
+  }
+};
+var toReadonlyArray = toReadonlyArray_;
+var reverseChunk = (self) => {
+  switch (self.backing._tag) {
+    case "IEmpty":
+    case "ISingleton":
+      return self;
+    case "IArray": {
+      return makeChunk({
+        _tag: "IArray",
+        array: reverse(self.backing.array)
+      });
+    }
+    case "IConcat": {
+      return makeChunk({
+        _tag: "IConcat",
+        left: reverse2(self.backing.right),
+        right: reverse2(self.backing.left)
+      });
+    }
+    case "ISlice":
+      return unsafeFromArray(reverse(toReadonlyArray(self)));
+  }
+};
+var reverse2 = reverseChunk;
+var unsafeFromArray = (self) => self.length === 0 ? empty2() : self.length === 1 ? of(self[0]) : makeChunk({
+  _tag: "IArray",
+  array: self
+});
+var unsafeFromNonEmptyArray = (self) => unsafeFromArray(self);
+var unsafeGet2 = /* @__PURE__ */ dual(2, (self, index) => {
+  switch (self.backing._tag) {
+    case "IEmpty": {
+      throw new Error(`Index out of bounds`);
+    }
+    case "ISingleton": {
+      if (index !== 0) {
+        throw new Error(`Index out of bounds`);
+      }
+      return self.backing.a;
+    }
+    case "IArray": {
+      if (index >= self.length || index < 0) {
+        throw new Error(`Index out of bounds`);
+      }
+      return self.backing.array[index];
+    }
+    case "IConcat": {
+      return index < self.left.length ? unsafeGet2(self.left, index) : unsafeGet2(self.right, index - self.left.length);
+    }
+    case "ISlice": {
+      return unsafeGet2(self.backing.chunk, index + self.backing.offset);
+    }
+  }
+});
+var prepend = /* @__PURE__ */ dual(2, (self, elem) => appendAll2(of(elem), self));
+var appendAll2 = /* @__PURE__ */ dual(2, (self, that) => {
+  if (self.backing._tag === "IEmpty") {
+    return that;
+  }
+  if (that.backing._tag === "IEmpty") {
+    return self;
+  }
+  const diff = that.depth - self.depth;
+  if (Math.abs(diff) <= 1) {
+    return makeChunk({
+      _tag: "IConcat",
+      left: self,
+      right: that
+    });
+  } else if (diff < -1) {
+    if (self.left.depth >= self.right.depth) {
+      const nr = appendAll2(self.right, that);
+      return makeChunk({
+        _tag: "IConcat",
+        left: self.left,
+        right: nr
+      });
+    } else {
+      const nrr = appendAll2(self.right.right, that);
+      if (nrr.depth === self.depth - 3) {
+        const nr = makeChunk({
+          _tag: "IConcat",
+          left: self.right.left,
+          right: nrr
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: self.left,
+          right: nr
+        });
+      } else {
+        const nl = makeChunk({
+          _tag: "IConcat",
+          left: self.left,
+          right: self.right.left
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nl,
+          right: nrr
+        });
+      }
+    }
+  } else {
+    if (that.right.depth >= that.left.depth) {
+      const nl = appendAll2(self, that.left);
+      return makeChunk({
+        _tag: "IConcat",
+        left: nl,
+        right: that.right
+      });
+    } else {
+      const nll = appendAll2(self, that.left.left);
+      if (nll.depth === that.depth - 3) {
+        const nl = makeChunk({
+          _tag: "IConcat",
+          left: nll,
+          right: that.left.right
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nl,
+          right: that.right
+        });
+      } else {
+        const nr = makeChunk({
+          _tag: "IConcat",
+          left: that.left.right,
+          right: that.right
+        });
+        return makeChunk({
+          _tag: "IConcat",
+          left: nll,
+          right: nr
+        });
+      }
+    }
+  }
+});
+var isEmpty = (self) => self.length === 0;
+var isNonEmpty = (self) => self.length > 0;
+var unsafeHead = (self) => unsafeGet2(self, 0);
+var headNonEmpty2 = unsafeHead;
 
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/encoding/base64.js
-var encode = (bytes) => {
-  const length = bytes.length;
-  let result = "";
-  let i;
-  for (i = 2; i < length; i += 3) {
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
-    result += base64abc[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
-    result += base64abc[bytes[i] & 63];
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/hashMap/config.js
+var SIZE = 5;
+var BUCKET_SIZE = /* @__PURE__ */ Math.pow(2, SIZE);
+var MASK = BUCKET_SIZE - 1;
+var MAX_INDEX_NODE = BUCKET_SIZE / 2;
+var MIN_ARRAY_NODE = BUCKET_SIZE / 4;
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/hashMap/bitwise.js
+function popcount(x) {
+  x -= x >> 1 & 1431655765;
+  x = (x & 858993459) + (x >> 2 & 858993459);
+  x = x + (x >> 4) & 252645135;
+  x += x >> 8;
+  x += x >> 16;
+  return x & 127;
+}
+function hashFragment(shift, h) {
+  return h >>> shift & MASK;
+}
+function toBitmap(x) {
+  return 1 << x;
+}
+function fromBitmap(bitmap, bit) {
+  return popcount(bitmap & bit - 1);
+}
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/stack.js
+var make5 = (value, previous) => ({
+  value,
+  previous
+});
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/hashMap/array.js
+function arrayUpdate(mutate3, at, v, arr) {
+  let out = arr;
+  if (!mutate3) {
+    const len = arr.length;
+    out = new Array(len);
+    for (let i = 0; i < len; ++i) out[i] = arr[i];
+  }
+  out[at] = v;
+  return out;
+}
+function arraySpliceOut(mutate3, at, arr) {
+  const newLen = arr.length - 1;
+  let i = 0;
+  let g = 0;
+  let out = arr;
+  if (mutate3) {
+    i = g = at;
+  } else {
+    out = new Array(newLen);
+    while (i < at) out[g++] = arr[i++];
   }
-  if (i === length + 1) {
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[(bytes[i - 2] & 3) << 4];
-    result += "==";
+  ++i;
+  while (i <= newLen) out[g++] = arr[i++];
+  if (mutate3) {
+    out.length = newLen;
   }
-  if (i === length) {
-    result += base64abc[bytes[i - 2] >> 2];
-    result += base64abc[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
-    result += base64abc[(bytes[i - 1] & 15) << 2];
-    result += "=";
+  return out;
+}
+function arraySpliceIn(mutate3, at, v, arr) {
+  const len = arr.length;
+  if (mutate3) {
+    let i2 = len;
+    while (i2 >= at) arr[i2--] = arr[i2];
+    arr[at] = v;
+    return arr;
+  }
+  let i = 0, g = 0;
+  const out = new Array(len + 1);
+  while (i < at) out[g++] = arr[i++];
+  out[at] = v;
+  while (i < len) out[++g] = arr[i++];
+  return out;
+}
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/hashMap/node.js
+var EmptyNode = class _EmptyNode {
+  _tag = "EmptyNode";
+  modify(edit, _shift, f, hash2, key, size4) {
+    const v = f(none2());
+    if (isNone2(v)) return new _EmptyNode();
+    ++size4.value;
+    return new LeafNode(edit, hash2, key, v);
+  }
+};
+function isEmptyNode(a) {
+  return isTagged(a, "EmptyNode");
+}
+function isLeafNode(node) {
+  return isEmptyNode(node) || node._tag === "LeafNode" || node._tag === "CollisionNode";
+}
+function canEditNode(node, edit) {
+  return isEmptyNode(node) ? false : edit === node.edit;
+}
+var LeafNode = class _LeafNode {
+  edit;
+  hash;
+  key;
+  value;
+  _tag = "LeafNode";
+  constructor(edit, hash2, key, value) {
+    this.edit = edit;
+    this.hash = hash2;
+    this.key = key;
+    this.value = value;
+  }
+  modify(edit, shift, f, hash2, key, size4) {
+    if (equals(key, this.key)) {
+      const v2 = f(this.value);
+      if (v2 === this.value) return this;
+      else if (isNone2(v2)) {
+        --size4.value;
+        return new EmptyNode();
+      }
+      if (canEditNode(this, edit)) {
+        this.value = v2;
+        return this;
+      }
+      return new _LeafNode(edit, hash2, key, v2);
+    }
+    const v = f(none2());
+    if (isNone2(v)) return this;
+    ++size4.value;
+    return mergeLeaves(edit, shift, this.hash, this, hash2, new _LeafNode(edit, hash2, key, v));
+  }
+};
+var CollisionNode = class _CollisionNode {
+  edit;
+  hash;
+  children;
+  _tag = "CollisionNode";
+  constructor(edit, hash2, children) {
+    this.edit = edit;
+    this.hash = hash2;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash2, key, size4) {
+    if (hash2 === this.hash) {
+      const canEdit = canEditNode(this, edit);
+      const list = this.updateCollisionList(canEdit, edit, this.hash, this.children, f, key, size4);
+      if (list === this.children) return this;
+      return list.length > 1 ? new _CollisionNode(edit, this.hash, list) : list[0];
+    }
+    const v = f(none2());
+    if (isNone2(v)) return this;
+    ++size4.value;
+    return mergeLeaves(edit, shift, this.hash, this, hash2, new LeafNode(edit, hash2, key, v));
+  }
+  updateCollisionList(mutate3, edit, hash2, list, f, key, size4) {
+    const len = list.length;
+    for (let i = 0; i < len; ++i) {
+      const child = list[i];
+      if ("key" in child && equals(key, child.key)) {
+        const value = child.value;
+        const newValue2 = f(value);
+        if (newValue2 === value) return list;
+        if (isNone2(newValue2)) {
+          --size4.value;
+          return arraySpliceOut(mutate3, i, list);
+        }
+        return arrayUpdate(mutate3, i, new LeafNode(edit, hash2, key, newValue2), list);
+      }
+    }
+    const newValue = f(none2());
+    if (isNone2(newValue)) return list;
+    ++size4.value;
+    return arrayUpdate(mutate3, len, new LeafNode(edit, hash2, key, newValue), list);
+  }
+};
+var IndexedNode = class _IndexedNode {
+  edit;
+  mask;
+  children;
+  _tag = "IndexedNode";
+  constructor(edit, mask, children) {
+    this.edit = edit;
+    this.mask = mask;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash2, key, size4) {
+    const mask = this.mask;
+    const children = this.children;
+    const frag = hashFragment(shift, hash2);
+    const bit = toBitmap(frag);
+    const indx = fromBitmap(mask, bit);
+    const exists = mask & bit;
+    const canEdit = canEditNode(this, edit);
+    if (!exists) {
+      const _newChild = new EmptyNode().modify(edit, shift + SIZE, f, hash2, key, size4);
+      if (!_newChild) return this;
+      return children.length >= MAX_INDEX_NODE ? expand(edit, frag, _newChild, mask, children) : new _IndexedNode(edit, mask | bit, arraySpliceIn(canEdit, indx, _newChild, children));
+    }
+    const current = children[indx];
+    const child = current.modify(edit, shift + SIZE, f, hash2, key, size4);
+    if (current === child) return this;
+    let bitmap = mask;
+    let newChildren;
+    if (isEmptyNode(child)) {
+      bitmap &= ~bit;
+      if (!bitmap) return new EmptyNode();
+      if (children.length <= 2 && isLeafNode(children[indx ^ 1])) {
+        return children[indx ^ 1];
+      }
+      newChildren = arraySpliceOut(canEdit, indx, children);
+    } else {
+      newChildren = arrayUpdate(canEdit, indx, child, children);
+    }
+    if (canEdit) {
+      this.mask = bitmap;
+      this.children = newChildren;
+      return this;
+    }
+    return new _IndexedNode(edit, bitmap, newChildren);
+  }
+};
+var ArrayNode = class _ArrayNode {
+  edit;
+  size;
+  children;
+  _tag = "ArrayNode";
+  constructor(edit, size4, children) {
+    this.edit = edit;
+    this.size = size4;
+    this.children = children;
+  }
+  modify(edit, shift, f, hash2, key, size4) {
+    let count = this.size;
+    const children = this.children;
+    const frag = hashFragment(shift, hash2);
+    const child = children[frag];
+    const newChild = (child || new EmptyNode()).modify(edit, shift + SIZE, f, hash2, key, size4);
+    if (child === newChild) return this;
+    const canEdit = canEditNode(this, edit);
+    let newChildren;
+    if (isEmptyNode(child) && !isEmptyNode(newChild)) {
+      ++count;
+      newChildren = arrayUpdate(canEdit, frag, newChild, children);
+    } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
+      --count;
+      if (count <= MIN_ARRAY_NODE) {
+        return pack(edit, count, frag, children);
+      }
+      newChildren = arrayUpdate(canEdit, frag, new EmptyNode(), children);
+    } else {
+      newChildren = arrayUpdate(canEdit, frag, newChild, children);
+    }
+    if (canEdit) {
+      this.size = count;
+      this.children = newChildren;
+      return this;
+    }
+    return new _ArrayNode(edit, count, newChildren);
+  }
+};
+function pack(edit, count, removed, elements) {
+  const children = new Array(count - 1);
+  let g = 0;
+  let bitmap = 0;
+  for (let i = 0, len = elements.length; i < len; ++i) {
+    if (i !== removed) {
+      const elem = elements[i];
+      if (elem && !isEmptyNode(elem)) {
+        children[g++] = elem;
+        bitmap |= 1 << i;
+      }
+    }
+  }
+  return new IndexedNode(edit, bitmap, children);
+}
+function expand(edit, frag, child, bitmap, subNodes) {
+  const arr = [];
+  let bit = bitmap;
+  let count = 0;
+  for (let i = 0; bit; ++i) {
+    if (bit & 1) arr[i] = subNodes[count++];
+    bit >>>= 1;
+  }
+  arr[frag] = child;
+  return new ArrayNode(edit, count + 1, arr);
+}
+function mergeLeavesInner(edit, shift, h1, n1, h2, n2) {
+  if (h1 === h2) return new CollisionNode(edit, h1, [n2, n1]);
+  const subH1 = hashFragment(shift, h1);
+  const subH2 = hashFragment(shift, h2);
+  if (subH1 === subH2) {
+    return (child) => new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), [child]);
+  } else {
+    const children = subH1 < subH2 ? [n1, n2] : [n2, n1];
+    return new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), children);
+  }
+}
+function mergeLeaves(edit, shift, h1, n1, h2, n2) {
+  let stack = void 0;
+  let currentShift = shift;
+  while (true) {
+    const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
+    if (typeof res === "function") {
+      stack = make5(res, stack);
+      currentShift = currentShift + SIZE;
+    } else {
+      let final = res;
+      while (stack != null) {
+        final = stack.value(final);
+        stack = stack.previous;
+      }
+      return final;
+    }
+  }
+}
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/hashMap.js
+var HashMapSymbolKey = "effect/HashMap";
+var HashMapTypeId = /* @__PURE__ */ Symbol.for(HashMapSymbolKey);
+var HashMapProto = {
+  [HashMapTypeId]: HashMapTypeId,
+  [Symbol.iterator]() {
+    return new HashMapIterator(this, (k, v) => [k, v]);
+  },
+  [symbol]() {
+    let hash2 = hash(HashMapSymbolKey);
+    for (const item of this) {
+      hash2 ^= pipe(hash(item[0]), combine(hash(item[1])));
+    }
+    return cached(this, hash2);
+  },
+  [symbol2](that) {
+    if (isHashMap(that)) {
+      if (that._size !== this._size) {
+        return false;
+      }
+      for (const item of this) {
+        const elem = pipe(that, getHash(item[0], hash(item[0])));
+        if (isNone2(elem)) {
+          return false;
+        } else {
+          if (!equals(item[1], elem.value)) {
+            return false;
+          }
+        }
+      }
+      return true;
+    }
+    return false;
+  },
+  toString() {
+    return format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "HashMap",
+      values: Array.from(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var makeImpl = (editable, edit, root, size4) => {
+  const map9 = Object.create(HashMapProto);
+  map9._editable = editable;
+  map9._edit = edit;
+  map9._root = root;
+  map9._size = size4;
+  return map9;
+};
+var HashMapIterator = class _HashMapIterator {
+  map;
+  f;
+  v;
+  constructor(map9, f) {
+    this.map = map9;
+    this.f = f;
+    this.v = visitLazy(this.map._root, this.f, void 0);
+  }
+  next() {
+    if (isNone2(this.v)) {
+      return {
+        done: true,
+        value: void 0
+      };
+    }
+    const v0 = this.v.value;
+    this.v = applyCont(v0.cont);
+    return {
+      done: false,
+      value: v0.value
+    };
+  }
+  [Symbol.iterator]() {
+    return new _HashMapIterator(this.map, this.f);
+  }
+};
+var applyCont = (cont) => cont ? visitLazyChildren(cont[0], cont[1], cont[2], cont[3], cont[4]) : none2();
+var visitLazy = (node, f, cont = void 0) => {
+  switch (node._tag) {
+    case "LeafNode": {
+      if (isSome2(node.value)) {
+        return some2({
+          value: f(node.key, node.value.value),
+          cont
+        });
+      }
+      return applyCont(cont);
+    }
+    case "CollisionNode":
+    case "ArrayNode":
+    case "IndexedNode": {
+      const children = node.children;
+      return visitLazyChildren(children.length, children, 0, f, cont);
+    }
+    default: {
+      return applyCont(cont);
+    }
+  }
+};
+var visitLazyChildren = (len, children, i, f, cont) => {
+  while (i < len) {
+    const child = children[i++];
+    if (child && !isEmptyNode(child)) {
+      return visitLazy(child, f, [len, children, i, f, cont]);
+    }
+  }
+  return applyCont(cont);
+};
+var _empty2 = /* @__PURE__ */ makeImpl(false, 0, /* @__PURE__ */ new EmptyNode(), 0);
+var empty3 = () => _empty2;
+var isHashMap = (u) => hasProperty(u, HashMapTypeId);
+var getHash = /* @__PURE__ */ dual(3, (self, key, hash2) => {
+  let node = self._root;
+  let shift = 0;
+  while (true) {
+    switch (node._tag) {
+      case "LeafNode": {
+        return equals(key, node.key) ? node.value : none2();
+      }
+      case "CollisionNode": {
+        if (hash2 === node.hash) {
+          const children = node.children;
+          for (let i = 0, len = children.length; i < len; ++i) {
+            const child = children[i];
+            if ("key" in child && equals(key, child.key)) {
+              return child.value;
+            }
+          }
+        }
+        return none2();
+      }
+      case "IndexedNode": {
+        const frag = hashFragment(shift, hash2);
+        const bit = toBitmap(frag);
+        if (node.mask & bit) {
+          node = node.children[fromBitmap(node.mask, bit)];
+          shift += SIZE;
+          break;
+        }
+        return none2();
+      }
+      case "ArrayNode": {
+        node = node.children[hashFragment(shift, hash2)];
+        if (node) {
+          shift += SIZE;
+          break;
+        }
+        return none2();
+      }
+      default:
+        return none2();
+    }
+  }
+});
+var set = /* @__PURE__ */ dual(3, (self, key, value) => modifyAt(self, key, () => some2(value)));
+var setTree = /* @__PURE__ */ dual(3, (self, newRoot, newSize) => {
+  if (self._editable) {
+    ;
+    self._root = newRoot;
+    self._size = newSize;
+    return self;
+  }
+  return newRoot === self._root ? self : makeImpl(self._editable, self._edit, newRoot, newSize);
+});
+var keys2 = (self) => new HashMapIterator(self, (key) => key);
+var size = (self) => self._size;
+var beginMutation = (self) => makeImpl(true, self._edit + 1, self._root, self._size);
+var modifyAt = /* @__PURE__ */ dual(3, (self, key, f) => modifyHash(self, key, hash(key), f));
+var modifyHash = /* @__PURE__ */ dual(4, (self, key, hash2, f) => {
+  const size4 = {
+    value: self._size
+  };
+  const newRoot = self._root.modify(self._editable ? self._edit : NaN, 0, f, hash2, key, size4);
+  return pipe(self, setTree(newRoot, size4.value));
+});
+var forEach = /* @__PURE__ */ dual(2, (self, f) => reduce2(self, void 0, (_, value, key) => f(value, key)));
+var reduce2 = /* @__PURE__ */ dual(3, (self, zero2, f) => {
+  const root = self._root;
+  if (root._tag === "LeafNode") {
+    return isSome2(root.value) ? f(zero2, root.value.value, root.key) : zero2;
+  }
+  if (root._tag === "EmptyNode") {
+    return zero2;
+  }
+  const toVisit = [root.children];
+  let children;
+  while (children = toVisit.pop()) {
+    for (let i = 0, len = children.length; i < len; ) {
+      const child = children[i++];
+      if (child && !isEmptyNode(child)) {
+        if (child._tag === "LeafNode") {
+          if (isSome2(child.value)) {
+            zero2 = f(zero2, child.value.value, child.key);
+          }
+        } else {
+          toVisit.push(child.children);
+        }
+      }
+    }
+  }
+  return zero2;
+});
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/hashSet.js
+var HashSetSymbolKey = "effect/HashSet";
+var HashSetTypeId = /* @__PURE__ */ Symbol.for(HashSetSymbolKey);
+var HashSetProto = {
+  [HashSetTypeId]: HashSetTypeId,
+  [Symbol.iterator]() {
+    return keys2(this._keyMap);
+  },
+  [symbol]() {
+    return cached(this, combine(hash(this._keyMap))(hash(HashSetSymbolKey)));
+  },
+  [symbol2](that) {
+    if (isHashSet(that)) {
+      return size(this._keyMap) === size(that._keyMap) && equals(this._keyMap, that._keyMap);
+    }
+    return false;
+  },
+  toString() {
+    return format(this.toJSON());
+  },
+  toJSON() {
+    return {
+      _id: "HashSet",
+      values: Array.from(this).map(toJSON)
+    };
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var makeImpl2 = (keyMap) => {
+  const set2 = Object.create(HashSetProto);
+  set2._keyMap = keyMap;
+  return set2;
+};
+var isHashSet = (u) => hasProperty(u, HashSetTypeId);
+var _empty3 = /* @__PURE__ */ makeImpl2(/* @__PURE__ */ empty3());
+var empty4 = () => _empty3;
+var size2 = (self) => size(self._keyMap);
+var beginMutation2 = (self) => makeImpl2(beginMutation(self._keyMap));
+var endMutation = (self) => {
+  ;
+  self._keyMap._editable = false;
+  return self;
+};
+var mutate = /* @__PURE__ */ dual(2, (self, f) => {
+  const transient = beginMutation2(self);
+  f(transient);
+  return endMutation(transient);
+});
+var add = /* @__PURE__ */ dual(2, (self, value) => self._keyMap._editable ? (set(value, true)(self._keyMap), self) : makeImpl2(set(value, true)(self._keyMap)));
+var union2 = /* @__PURE__ */ dual(2, (self, that) => mutate(empty4(), (set2) => {
+  forEach2(self, (value) => add(set2, value));
+  for (const value of that) {
+    add(set2, value);
+  }
+}));
+var forEach2 = /* @__PURE__ */ dual(2, (self, f) => forEach(self._keyMap, (_, k) => f(k)));
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/HashSet.js
+var empty5 = empty4;
+var size3 = size2;
+var add2 = add;
+var union3 = union2;
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/data.js
+var ArrayProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Array.prototype), {
+  [symbol]() {
+    return cached(this, array2(this));
+  },
+  [symbol2](that) {
+    if (Array.isArray(that) && this.length === that.length) {
+      return this.every((v, i) => equals(v, that[i]));
+    } else {
+      return false;
+    }
+  }
+});
+var Structural = /* @__PURE__ */ (function() {
+  function Structural2(args2) {
+    if (args2) {
+      Object.assign(this, args2);
+    }
+  }
+  Structural2.prototype = StructuralPrototype;
+  return Structural2;
+})();
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/opCodes/cause.js
+var OP_DIE = "Die";
+var OP_EMPTY = "Empty";
+var OP_FAIL = "Fail";
+var OP_INTERRUPT = "Interrupt";
+var OP_PARALLEL = "Parallel";
+var OP_SEQUENTIAL = "Sequential";
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/cause.js
+var CauseSymbolKey = "effect/Cause";
+var CauseTypeId = /* @__PURE__ */ Symbol.for(CauseSymbolKey);
+var variance = {
+  /* c8 ignore next */
+  _E: (_) => _
+};
+var proto = {
+  [CauseTypeId]: variance,
+  [symbol]() {
+    return pipe(hash(CauseSymbolKey), combine(hash(flattenCause(this))), cached(this));
+  },
+  [symbol2](that) {
+    return isCause(that) && causeEquals(this, that);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  },
+  toJSON() {
+    switch (this._tag) {
+      case "Empty":
+        return {
+          _id: "Cause",
+          _tag: this._tag
+        };
+      case "Die":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          defect: toJSON(this.defect)
+        };
+      case "Interrupt":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          fiberId: this.fiberId.toJSON()
+        };
+      case "Fail":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          failure: toJSON(this.error)
+        };
+      case "Sequential":
+      case "Parallel":
+        return {
+          _id: "Cause",
+          _tag: this._tag,
+          left: toJSON(this.left),
+          right: toJSON(this.right)
+        };
+    }
+  },
+  toString() {
+    return pretty(this);
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+};
+var fail2 = (error) => {
+  const o = Object.create(proto);
+  o._tag = OP_FAIL;
+  o.error = error;
+  return o;
+};
+var parallel = (left3, right3) => {
+  const o = Object.create(proto);
+  o._tag = OP_PARALLEL;
+  o.left = left3;
+  o.right = right3;
+  return o;
+};
+var sequential = (left3, right3) => {
+  const o = Object.create(proto);
+  o._tag = OP_SEQUENTIAL;
+  o.left = left3;
+  o.right = right3;
+  return o;
+};
+var isCause = (u) => hasProperty(u, CauseTypeId);
+var isInterruptedOnly = (self) => reduceWithContext(void 0, IsInterruptedOnlyCauseReducer)(self);
+var causeEquals = (left3, right3) => {
+  let leftStack = of(left3);
+  let rightStack = of(right3);
+  while (isNonEmpty(leftStack) && isNonEmpty(rightStack)) {
+    const [leftParallel, leftSequential] = pipe(headNonEmpty2(leftStack), reduce4([empty5(), empty2()], ([parallel2, sequential2], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some2([pipe(parallel2, union3(par)), pipe(sequential2, appendAll2(seq))]);
+    }));
+    const [rightParallel, rightSequential] = pipe(headNonEmpty2(rightStack), reduce4([empty5(), empty2()], ([parallel2, sequential2], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return some2([pipe(parallel2, union3(par)), pipe(sequential2, appendAll2(seq))]);
+    }));
+    if (!equals(leftParallel, rightParallel)) {
+      return false;
+    }
+    leftStack = leftSequential;
+    rightStack = rightSequential;
+  }
+  return true;
+};
+var flattenCause = (cause) => {
+  return flattenCauseLoop(of(cause), empty2());
+};
+var flattenCauseLoop = (causes, flattened) => {
+  while (1) {
+    const [parallel2, sequential2] = pipe(causes, reduce([empty5(), empty2()], ([parallel3, sequential3], cause) => {
+      const [par, seq] = evaluateCause(cause);
+      return [pipe(parallel3, union3(par)), pipe(sequential3, appendAll2(seq))];
+    }));
+    const updated = size3(parallel2) > 0 ? pipe(flattened, prepend(parallel2)) : flattened;
+    if (isEmpty(sequential2)) {
+      return reverse2(updated);
+    }
+    causes = sequential2;
+    flattened = updated;
+  }
+  throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"));
+};
+var evaluateCause = (self) => {
+  let cause = self;
+  const stack = [];
+  let _parallel = empty5();
+  let _sequential = empty2();
+  while (cause !== void 0) {
+    switch (cause._tag) {
+      case OP_EMPTY: {
+        if (stack.length === 0) {
+          return [_parallel, _sequential];
+        }
+        cause = stack.pop();
+        break;
+      }
+      case OP_FAIL: {
+        _parallel = add2(_parallel, make4(cause._tag, cause.error));
+        if (stack.length === 0) {
+          return [_parallel, _sequential];
+        }
+        cause = stack.pop();
+        break;
+      }
+      case OP_DIE: {
+        _parallel = add2(_parallel, make4(cause._tag, cause.defect));
+        if (stack.length === 0) {
+          return [_parallel, _sequential];
+        }
+        cause = stack.pop();
+        break;
+      }
+      case OP_INTERRUPT: {
+        _parallel = add2(_parallel, make4(cause._tag, cause.fiberId));
+        if (stack.length === 0) {
+          return [_parallel, _sequential];
+        }
+        cause = stack.pop();
+        break;
+      }
+      case OP_SEQUENTIAL: {
+        switch (cause.left._tag) {
+          case OP_EMPTY: {
+            cause = cause.right;
+            break;
+          }
+          case OP_SEQUENTIAL: {
+            cause = sequential(cause.left.left, sequential(cause.left.right, cause.right));
+            break;
+          }
+          case OP_PARALLEL: {
+            cause = parallel(sequential(cause.left.left, cause.right), sequential(cause.left.right, cause.right));
+            break;
+          }
+          default: {
+            _sequential = prepend(_sequential, cause.right);
+            cause = cause.left;
+            break;
+          }
+        }
+        break;
+      }
+      case OP_PARALLEL: {
+        stack.push(cause.right);
+        cause = cause.left;
+        break;
+      }
+    }
+  }
+  throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"));
+};
+var IsInterruptedOnlyCauseReducer = {
+  emptyCase: constTrue,
+  failCase: constFalse,
+  dieCase: constFalse,
+  interruptCase: constTrue,
+  sequentialCase: (_, left3, right3) => left3 && right3,
+  parallelCase: (_, left3, right3) => left3 && right3
+};
+var OP_SEQUENTIAL_CASE = "SequentialCase";
+var OP_PARALLEL_CASE = "ParallelCase";
+var reduce4 = /* @__PURE__ */ dual(3, (self, zero2, pf) => {
+  let accumulator = zero2;
+  let cause = self;
+  const causes = [];
+  while (cause !== void 0) {
+    const option2 = pf(accumulator, cause);
+    accumulator = isSome2(option2) ? option2.value : accumulator;
+    switch (cause._tag) {
+      case OP_SEQUENTIAL: {
+        causes.push(cause.right);
+        cause = cause.left;
+        break;
+      }
+      case OP_PARALLEL: {
+        causes.push(cause.right);
+        cause = cause.left;
+        break;
+      }
+      default: {
+        cause = void 0;
+        break;
+      }
+    }
+    if (cause === void 0 && causes.length > 0) {
+      cause = causes.pop();
+    }
+  }
+  return accumulator;
+});
+var reduceWithContext = /* @__PURE__ */ dual(3, (self, context, reducer) => {
+  const input = [self];
+  const output = [];
+  while (input.length > 0) {
+    const cause = input.pop();
+    switch (cause._tag) {
+      case OP_EMPTY: {
+        output.push(right2(reducer.emptyCase(context)));
+        break;
+      }
+      case OP_FAIL: {
+        output.push(right2(reducer.failCase(context, cause.error)));
+        break;
+      }
+      case OP_DIE: {
+        output.push(right2(reducer.dieCase(context, cause.defect)));
+        break;
+      }
+      case OP_INTERRUPT: {
+        output.push(right2(reducer.interruptCase(context, cause.fiberId)));
+        break;
+      }
+      case OP_SEQUENTIAL: {
+        input.push(cause.right);
+        input.push(cause.left);
+        output.push(left2({
+          _tag: OP_SEQUENTIAL_CASE
+        }));
+        break;
+      }
+      case OP_PARALLEL: {
+        input.push(cause.right);
+        input.push(cause.left);
+        output.push(left2({
+          _tag: OP_PARALLEL_CASE
+        }));
+        break;
+      }
+    }
+  }
+  const accumulator = [];
+  while (output.length > 0) {
+    const either = output.pop();
+    switch (either._tag) {
+      case "Left": {
+        switch (either.left._tag) {
+          case OP_SEQUENTIAL_CASE: {
+            const left3 = accumulator.pop();
+            const right3 = accumulator.pop();
+            const value = reducer.sequentialCase(context, left3, right3);
+            accumulator.push(value);
+            break;
+          }
+          case OP_PARALLEL_CASE: {
+            const left3 = accumulator.pop();
+            const right3 = accumulator.pop();
+            const value = reducer.parallelCase(context, left3, right3);
+            accumulator.push(value);
+            break;
+          }
+        }
+        break;
+      }
+      case "Right": {
+        accumulator.push(either.right);
+        break;
+      }
+    }
+  }
+  if (accumulator.length === 0) {
+    throw new Error("BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/effect/issues");
+  }
+  return accumulator.pop();
+});
+var pretty = (cause, options) => {
+  if (isInterruptedOnly(cause)) {
+    return "All fibers interrupted without errors.";
+  }
+  return prettyErrors(cause).map(function(e) {
+    if (options?.renderErrorCause !== true || e.cause === void 0) {
+      return e.stack;
+    }
+    return `${e.stack} {
+${renderErrorCause(e.cause, "  ")}
+}`;
+  }).join("\n");
+};
+var renderErrorCause = (cause, prefix) => {
+  const lines = cause.stack.split("\n");
+  let stack = `${prefix}[cause]: ${lines[0]}`;
+  for (let i = 1, len = lines.length; i < len; i++) {
+    stack += `
+${prefix}${lines[i]}`;
+  }
+  if (cause.cause) {
+    stack += ` {
+${renderErrorCause(cause.cause, `${prefix}  `)}
+${prefix}}`;
+  }
+  return stack;
+};
+var PrettyError = class _PrettyError extends globalThis.Error {
+  span = void 0;
+  constructor(originalError) {
+    const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
+    const prevLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = 1;
+    super(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
+      cause: new _PrettyError(originalError.cause)
+    } : void 0);
+    if (this.message === "") {
+      this.message = "An error has occurred";
+    }
+    Error.stackTraceLimit = prevLimit;
+    this.name = originalError instanceof Error ? originalError.name : "Error";
+    if (originalErrorIsObject) {
+      if (spanSymbol in originalError) {
+        this.span = originalError[spanSymbol];
+      }
+      Object.keys(originalError).forEach((key) => {
+        if (!(key in this)) {
+          this[key] = originalError[key];
+        }
+      });
+    }
+    this.stack = prettyErrorStack(`${this.name}: ${this.message}`, originalError instanceof Error && originalError.stack ? originalError.stack : "", this.span);
+  }
+};
+var prettyErrorMessage = (u) => {
+  if (typeof u === "string") {
+    return u;
+  }
+  if (typeof u === "object" && u !== null && u instanceof Error) {
+    return u.message;
+  }
+  try {
+    if (hasProperty(u, "toString") && isFunction2(u["toString"]) && u["toString"] !== Object.prototype.toString && u["toString"] !== globalThis.Array.prototype.toString) {
+      return u["toString"]();
+    }
+  } catch {
+  }
+  return stringifyCircular(u);
+};
+var locationRegex = /\((.*)\)/g;
+var spanToTrace = /* @__PURE__ */ globalValue("effect/Tracer/spanToTrace", () => /* @__PURE__ */ new WeakMap());
+var prettyErrorStack = (message, stack, span) => {
+  const out = [message];
+  const lines = stack.startsWith(message) ? stack.slice(message.length).split("\n") : stack.split("\n");
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].includes(" at new BaseEffectError") || lines[i].includes(" at new YieldableError")) {
+      i++;
+      continue;
+    }
+    if (lines[i].includes("Generator.next")) {
+      break;
+    }
+    if (lines[i].includes("effect_internal_function")) {
+      break;
+    }
+    out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>"));
+  }
+  if (span) {
+    let current = span;
+    let i = 0;
+    while (current && current._tag === "Span" && i < 10) {
+      const stackFn = spanToTrace.get(current);
+      if (typeof stackFn === "function") {
+        const stack2 = stackFn();
+        if (typeof stack2 === "string") {
+          const locationMatchAll = stack2.matchAll(locationRegex);
+          let match3 = false;
+          for (const [, location] of locationMatchAll) {
+            match3 = true;
+            out.push(`    at ${current.name} (${location})`);
+          }
+          if (!match3) {
+            out.push(`    at ${current.name} (${stack2.replace(/^at /, "")})`);
+          }
+        } else {
+          out.push(`    at ${current.name}`);
+        }
+      } else {
+        out.push(`    at ${current.name}`);
+      }
+      current = getOrUndefined(current.parent);
+      i++;
+    }
+  }
+  return out.join("\n");
+};
+var spanSymbol = /* @__PURE__ */ Symbol.for("effect/SpanAnnotation");
+var prettyErrors = (cause) => reduceWithContext(cause, void 0, {
+  emptyCase: () => [],
+  dieCase: (_, unknownError) => {
+    return [new PrettyError(unknownError)];
+  },
+  failCase: (_, error) => {
+    return [new PrettyError(error)];
+  },
+  interruptCase: () => [],
+  parallelCase: (_, l, r) => [...l, ...r],
+  sequentialCase: (_, l, r) => [...l, ...r]
+});
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/singleShotGen.js
+var SingleShotGen3 = class _SingleShotGen {
+  self;
+  called = false;
+  constructor(self) {
+    this.self = self;
+  }
+  next(a) {
+    return this.called ? {
+      value: a,
+      done: true
+    } : (this.called = true, {
+      value: this.self,
+      done: false
+    });
+  }
+  return(a) {
+    return {
+      value: a,
+      done: true
+    };
+  }
+  throw(e) {
+    throw e;
+  }
+  [Symbol.iterator]() {
+    return new _SingleShotGen(this.self);
+  }
+};
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/core.js
+var EffectTypeId2 = /* @__PURE__ */ Symbol.for("effect/Effect");
+var EffectPrimitive = class {
+  _op;
+  effect_instruction_i0 = void 0;
+  effect_instruction_i1 = void 0;
+  effect_instruction_i2 = void 0;
+  trace = void 0;
+  [EffectTypeId2] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+  }
+  [symbol2](that) {
+    return this === that;
+  }
+  [symbol]() {
+    return cached(this, random(this));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Effect",
+      _op: this._op,
+      effect_instruction_i0: toJSON(this.effect_instruction_i0),
+      effect_instruction_i1: toJSON(this.effect_instruction_i1),
+      effect_instruction_i2: toJSON(this.effect_instruction_i2)
+    };
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen3(new YieldWrap(this));
+  }
+};
+var EffectPrimitiveFailure = class {
+  _op;
+  effect_instruction_i0 = void 0;
+  effect_instruction_i1 = void 0;
+  effect_instruction_i2 = void 0;
+  trace = void 0;
+  [EffectTypeId2] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+    this._tag = _op;
+  }
+  [symbol2](that) {
+    return exitIsExit(that) && that._op === "Failure" && // @ts-expect-error
+    equals(this.effect_instruction_i0, that.effect_instruction_i0);
+  }
+  [symbol]() {
+    return pipe(
+      // @ts-expect-error
+      string(this._tag),
+      // @ts-expect-error
+      combine(hash(this.effect_instruction_i0)),
+      cached(this)
+    );
+  }
+  get cause() {
+    return this.effect_instruction_i0;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Exit",
+      _tag: this._op,
+      cause: this.cause.toJSON()
+    };
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen3(new YieldWrap(this));
+  }
+};
+var EffectPrimitiveSuccess = class {
+  _op;
+  effect_instruction_i0 = void 0;
+  effect_instruction_i1 = void 0;
+  effect_instruction_i2 = void 0;
+  trace = void 0;
+  [EffectTypeId2] = effectVariance;
+  constructor(_op) {
+    this._op = _op;
+    this._tag = _op;
+  }
+  [symbol2](that) {
+    return exitIsExit(that) && that._op === "Success" && // @ts-expect-error
+    equals(this.effect_instruction_i0, that.effect_instruction_i0);
+  }
+  [symbol]() {
+    return pipe(
+      // @ts-expect-error
+      string(this._tag),
+      // @ts-expect-error
+      combine(hash(this.effect_instruction_i0)),
+      cached(this)
+    );
+  }
+  get value() {
+    return this.effect_instruction_i0;
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+  toJSON() {
+    return {
+      _id: "Exit",
+      _tag: this._op,
+      value: toJSON(this.value)
+    };
+  }
+  toString() {
+    return format(this.toJSON());
+  }
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  }
+  [Symbol.iterator]() {
+    return new SingleShotGen3(new YieldWrap(this));
+  }
+};
+var isEffect = (u) => hasProperty(u, EffectTypeId2);
+var withFiberRuntime = (withRuntime) => {
+  const effect = new EffectPrimitive(OP_WITH_RUNTIME);
+  effect.effect_instruction_i0 = withRuntime;
+  return effect;
+};
+var originalSymbol = /* @__PURE__ */ Symbol.for("effect/OriginalAnnotation");
+var capture = (obj, span) => {
+  if (isSome2(span)) {
+    return new Proxy(obj, {
+      has(target, p) {
+        return p === spanSymbol || p === originalSymbol || p in target;
+      },
+      get(target, p) {
+        if (p === spanSymbol) {
+          return span.value;
+        }
+        if (p === originalSymbol) {
+          return obj;
+        }
+        return target[p];
+      }
+    });
+  }
+  return obj;
+};
+var fail3 = (error) => isObject(error) && !(spanSymbol in error) ? withFiberRuntime((fiber) => failCause(fail2(capture(error, currentSpanFromFiber(fiber))))) : failCause(fail2(error));
+var failCause = (cause) => {
+  const effect = new EffectPrimitiveFailure(OP_FAILURE);
+  effect.effect_instruction_i0 = cause;
+  return effect;
+};
+var logLevelAll = {
+  _tag: "All",
+  syslog: 0,
+  label: "ALL",
+  ordinal: Number.MIN_SAFE_INTEGER,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var logLevelNone = {
+  _tag: "None",
+  syslog: 7,
+  label: "OFF",
+  ordinal: Number.MAX_SAFE_INTEGER,
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var RequestResolverSymbolKey = "effect/RequestResolver";
+var RequestResolverTypeId = /* @__PURE__ */ Symbol.for(RequestResolverSymbolKey);
+var requestResolverVariance = {
+  /* c8 ignore next */
+  _A: (_) => _,
+  /* c8 ignore next */
+  _R: (_) => _
+};
+var RequestResolverImpl = class _RequestResolverImpl {
+  runAll;
+  target;
+  [RequestResolverTypeId] = requestResolverVariance;
+  constructor(runAll, target) {
+    this.runAll = runAll;
+    this.target = target;
+  }
+  [symbol]() {
+    return cached(this, this.target ? hash(this.target) : random(this));
+  }
+  [symbol2](that) {
+    return this.target ? isRequestResolver(that) && equals(this.target, that.target) : this === that;
+  }
+  identified(...ids) {
+    return new _RequestResolverImpl(this.runAll, fromIterable2(ids));
+  }
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var isRequestResolver = (u) => hasProperty(u, RequestResolverTypeId);
+var YieldableError = /* @__PURE__ */ (function() {
+  class YieldableError2 extends globalThis.Error {
+    commit() {
+      return fail3(this);
+    }
+    toJSON() {
+      const obj = {
+        ...this
+      };
+      if (this.message) obj.message = this.message;
+      if (this.cause) obj.cause = this.cause;
+      return obj;
+    }
+    [NodeInspectSymbol]() {
+      if (this.toString !== globalThis.Error.prototype.toString) {
+        return this.stack ? `${this.toString()}
+${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
+      } else if ("Bun" in globalThis) {
+        return pretty(fail2(this), {
+          renderErrorCause: true
+        });
+      }
+      return this;
+    }
+  }
+  Object.assign(YieldableError2.prototype, StructuralCommitPrototype);
+  return YieldableError2;
+})();
+var makeException = (proto2, tag) => {
+  class Base extends YieldableError {
+    _tag = tag;
+  }
+  Object.assign(Base.prototype, proto2);
+  Base.prototype.name = tag;
+  return Base;
+};
+var RuntimeExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/RuntimeException");
+var RuntimeException = /* @__PURE__ */ makeException({
+  [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
+}, "RuntimeException");
+var InterruptedExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/InterruptedException");
+var InterruptedException = /* @__PURE__ */ makeException({
+  [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
+}, "InterruptedException");
+var IllegalArgumentExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/IllegalArgument");
+var IllegalArgumentException = /* @__PURE__ */ makeException({
+  [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
+}, "IllegalArgumentException");
+var NoSuchElementExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/NoSuchElement");
+var NoSuchElementException = /* @__PURE__ */ makeException({
+  [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
+}, "NoSuchElementException");
+var InvalidPubSubCapacityExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/InvalidPubSubCapacityException");
+var InvalidPubSubCapacityException = /* @__PURE__ */ makeException({
+  [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
+}, "InvalidPubSubCapacityException");
+var ExceededCapacityExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/ExceededCapacityException");
+var ExceededCapacityException = /* @__PURE__ */ makeException({
+  [ExceededCapacityExceptionTypeId]: ExceededCapacityExceptionTypeId
+}, "ExceededCapacityException");
+var TimeoutExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/Timeout");
+var TimeoutException = /* @__PURE__ */ makeException({
+  [TimeoutExceptionTypeId]: TimeoutExceptionTypeId
+}, "TimeoutException");
+var exitIsExit = (u) => isEffect(u) && "_tag" in u && (u._tag === "Success" || u._tag === "Failure");
+var currentSpanFromFiber = (fiber) => {
+  const span = fiber.currentSpan;
+  return span !== void 0 && span._tag === "Span" ? some2(span) : none2();
+};
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Data.js
+var Class2 = Structural;
+var Error2 = /* @__PURE__ */ (function() {
+  const plainArgsSymbol = /* @__PURE__ */ Symbol.for("effect/Data/Error/plainArgs");
+  const O = {
+    BaseEffectError: class extends YieldableError {
+      constructor(args2) {
+        super(args2?.message, args2?.cause ? {
+          cause: args2.cause
+        } : void 0);
+        if (args2) {
+          Object.assign(this, args2);
+          Object.defineProperty(this, plainArgsSymbol, {
+            value: args2,
+            enumerable: false
+          });
+        }
+      }
+      toJSON() {
+        return {
+          ...this[plainArgsSymbol],
+          ...this
+        };
+      }
+    }
+  };
+  return O.BaseEffectError;
+})();
+var TaggedError = (tag) => {
+  const O = {
+    BaseEffectError: class extends Error2 {
+      _tag = tag;
+    }
+  };
+  O.BaseEffectError.prototype.name = tag;
+  return O.BaseEffectError;
+};
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/encoding/common.js
+var encoder = /* @__PURE__ */ new TextEncoder();
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/encoding/base64.js
+var encode = (bytes) => {
+  const length = bytes.length;
+  let result = "";
+  let i;
+  for (i = 2; i < length; i += 3) {
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+    result += base64abc[(bytes[i - 1] & 15) << 2 | bytes[i] >> 6];
+    result += base64abc[bytes[i] & 63];
+  }
+  if (i === length + 1) {
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 3) << 4];
+    result += "==";
+  }
+  if (i === length) {
+    result += base64abc[bytes[i - 2] >> 2];
+    result += base64abc[(bytes[i - 2] & 3) << 4 | bytes[i - 1] >> 4];
+    result += base64abc[(bytes[i - 1] & 15) << 2];
+    result += "=";
+  }
+  return result;
+};
+var base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/internal/encoding/base64Url.js
+var encode2 = (data) => encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Encoding.js
+var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
+
+// node_modules/.pnpm/@pkg.pr.new+Effect-TS+effect@97ff1dc_6ntygjheib5kdugabxjhox4fte/node_modules/effect/dist/esm/Graph.js
+var TypeId4 = "~effect/Graph";
+var Edge = class extends Class2 {
+};
+var ProtoGraph = {
+  [TypeId4]: TypeId4,
+  [Symbol.iterator]() {
+    return this.nodes[Symbol.iterator]();
+  },
+  [NodeInspectSymbol]() {
+    return this.toJSON();
+  },
+  [symbol2](that) {
+    if (isGraph(that)) {
+      if (this.nodes.size !== that.nodes.size || this.edges.size !== that.edges.size || this.type !== that.type) {
+        return false;
+      }
+      for (const [nodeIndex, nodeData] of this.nodes) {
+        if (!that.nodes.has(nodeIndex)) {
+          return false;
+        }
+        const otherNodeData = that.nodes.get(nodeIndex);
+        if (!equals(nodeData, otherNodeData)) {
+          return false;
+        }
+      }
+      for (const [edgeIndex, edgeData] of this.edges) {
+        if (!that.edges.has(edgeIndex)) {
+          return false;
+        }
+        const otherEdge = that.edges.get(edgeIndex);
+        if (!equals(edgeData, otherEdge)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    return false;
+  },
+  [symbol]() {
+    let hash2 = string("Graph");
+    hash2 = hash2 ^ string(this.type);
+    hash2 = hash2 ^ number(this.nodes.size);
+    hash2 = hash2 ^ number(this.edges.size);
+    for (const [nodeIndex, nodeData] of this.nodes) {
+      hash2 = hash2 ^ hash(nodeIndex) + hash(nodeData);
+    }
+    for (const [edgeIndex, edgeData] of this.edges) {
+      hash2 = hash2 ^ hash(edgeIndex) + hash(edgeData);
+    }
+    return hash2;
+  },
+  toJSON() {
+    return {
+      _id: "Graph",
+      nodeCount: this.nodes.size,
+      edgeCount: this.edges.size,
+      type: this.type
+    };
+  },
+  toString() {
+    return format(this);
+  },
+  pipe() {
+    return pipeArguments(this, arguments);
+  }
+};
+var GraphError = class extends (/* @__PURE__ */ TaggedError("GraphError")) {
+};
+var missingNode = (node) => new GraphError({
+  message: `Node ${node} does not exist`
+});
+var isGraph = (u) => typeof u === "object" && u !== null && TypeId4 in u;
+var directed = (mutate3) => {
+  const graph = Object.create(ProtoGraph);
+  graph.type = "directed";
+  graph.nodes = /* @__PURE__ */ new Map();
+  graph.edges = /* @__PURE__ */ new Map();
+  graph.adjacency = /* @__PURE__ */ new Map();
+  graph.reverseAdjacency = /* @__PURE__ */ new Map();
+  graph.nextNodeIndex = 0;
+  graph.nextEdgeIndex = 0;
+  graph.isAcyclic = some2(true);
+  graph.mutable = false;
+  if (mutate3) {
+    const mutable = beginMutation3(graph);
+    mutate3(mutable);
+    return endMutation2(mutable);
+  }
+  return graph;
+};
+var beginMutation3 = (graph) => {
+  const adjacency = /* @__PURE__ */ new Map();
+  const reverseAdjacency = /* @__PURE__ */ new Map();
+  for (const [nodeIndex, edges2] of graph.adjacency) {
+    adjacency.set(nodeIndex, [...edges2]);
+  }
+  for (const [nodeIndex, edges2] of graph.reverseAdjacency) {
+    reverseAdjacency.set(nodeIndex, [...edges2]);
+  }
+  const mutable = Object.create(ProtoGraph);
+  mutable.type = graph.type;
+  mutable.nodes = new Map(graph.nodes);
+  mutable.edges = new Map(graph.edges);
+  mutable.adjacency = adjacency;
+  mutable.reverseAdjacency = reverseAdjacency;
+  mutable.nextNodeIndex = graph.nextNodeIndex;
+  mutable.nextEdgeIndex = graph.nextEdgeIndex;
+  mutable.isAcyclic = graph.isAcyclic;
+  mutable.mutable = true;
+  return mutable;
+};
+var endMutation2 = (mutable) => {
+  const graph = Object.create(ProtoGraph);
+  graph.type = mutable.type;
+  graph.nodes = new Map(mutable.nodes);
+  graph.edges = new Map(mutable.edges);
+  graph.adjacency = mutable.adjacency;
+  graph.reverseAdjacency = mutable.reverseAdjacency;
+  graph.nextNodeIndex = mutable.nextNodeIndex;
+  graph.nextEdgeIndex = mutable.nextEdgeIndex;
+  graph.isAcyclic = mutable.isAcyclic;
+  graph.mutable = false;
+  return graph;
+};
+var mutate2 = /* @__PURE__ */ dual(2, (graph, f) => {
+  const mutable = beginMutation3(graph);
+  f(mutable);
+  return endMutation2(mutable);
+});
+var addNode = (mutable, data) => {
+  const nodeIndex = mutable.nextNodeIndex;
+  mutable.nodes.set(nodeIndex, data);
+  mutable.adjacency.set(nodeIndex, []);
+  mutable.reverseAdjacency.set(nodeIndex, []);
+  mutable.nextNodeIndex = mutable.nextNodeIndex + 1;
+  return nodeIndex;
+};
+var getNode = (graph, nodeIndex) => graph.nodes.has(nodeIndex) ? some2(graph.nodes.get(nodeIndex)) : none2();
+var hasNode = (graph, nodeIndex) => graph.nodes.has(nodeIndex);
+var nodeCount = (graph) => graph.nodes.size;
+var reverse3 = (mutable) => {
+  for (const [index, edgeData] of mutable.edges) {
+    mutable.edges.set(index, {
+      source: edgeData.target,
+      target: edgeData.source,
+      data: edgeData.data
+    });
+  }
+  mutable.adjacency.clear();
+  mutable.reverseAdjacency.clear();
+  for (const [edgeIndex, edgeData] of mutable.edges) {
+    const sourceEdges = mutable.adjacency.get(edgeData.source) || [];
+    sourceEdges.push(edgeIndex);
+    mutable.adjacency.set(edgeData.source, sourceEdges);
+    const targetEdges = mutable.reverseAdjacency.get(edgeData.target) || [];
+    targetEdges.push(edgeIndex);
+    mutable.reverseAdjacency.set(edgeData.target, targetEdges);
+  }
+  mutable.isAcyclic = none2();
+};
+var invalidateCycleFlagOnRemoval = (mutable) => {
+  if (isSome2(mutable.isAcyclic) && mutable.isAcyclic.value === false) {
+    mutable.isAcyclic = none2();
+  }
+};
+var invalidateCycleFlagOnAddition = (mutable) => {
+  if (isSome2(mutable.isAcyclic) && mutable.isAcyclic.value === true) {
+    mutable.isAcyclic = none2();
+  }
+};
+var addEdge = (mutable, source, target, data) => {
+  if (!mutable.nodes.has(source)) {
+    throw missingNode(source);
+  }
+  if (!mutable.nodes.has(target)) {
+    throw missingNode(target);
+  }
+  const edgeIndex = mutable.nextEdgeIndex;
+  const edgeData = new Edge({
+    source,
+    target,
+    data
+  });
+  mutable.edges.set(edgeIndex, edgeData);
+  const sourceAdjacency = mutable.adjacency.get(source);
+  if (sourceAdjacency !== void 0) {
+    sourceAdjacency.push(edgeIndex);
+  }
+  const targetReverseAdjacency = mutable.reverseAdjacency.get(target);
+  if (targetReverseAdjacency !== void 0) {
+    targetReverseAdjacency.push(edgeIndex);
+  }
+  if (mutable.type === "undirected") {
+    const targetAdjacency = mutable.adjacency.get(target);
+    if (targetAdjacency !== void 0) {
+      targetAdjacency.push(edgeIndex);
+    }
+    const sourceReverseAdjacency = mutable.reverseAdjacency.get(source);
+    if (sourceReverseAdjacency !== void 0) {
+      sourceReverseAdjacency.push(edgeIndex);
+    }
+  }
+  mutable.nextEdgeIndex = mutable.nextEdgeIndex + 1;
+  invalidateCycleFlagOnAddition(mutable);
+  return edgeIndex;
+};
+var removeNode = (mutable, nodeIndex) => {
+  if (!mutable.nodes.has(nodeIndex)) {
+    return;
+  }
+  const edgesToRemove = [];
+  const outgoingEdges = mutable.adjacency.get(nodeIndex);
+  if (outgoingEdges !== void 0) {
+    for (const edge of outgoingEdges) {
+      edgesToRemove.push(edge);
+    }
+  }
+  const incomingEdges = mutable.reverseAdjacency.get(nodeIndex);
+  if (incomingEdges !== void 0) {
+    for (const edge of incomingEdges) {
+      edgesToRemove.push(edge);
+    }
+  }
+  for (const edgeIndex of edgesToRemove) {
+    removeEdgeInternal(mutable, edgeIndex);
+  }
+  mutable.nodes.delete(nodeIndex);
+  mutable.adjacency.delete(nodeIndex);
+  mutable.reverseAdjacency.delete(nodeIndex);
+  invalidateCycleFlagOnRemoval(mutable);
+};
+var removeEdgeInternal = (mutable, edgeIndex) => {
+  const edge = mutable.edges.get(edgeIndex);
+  if (edge === void 0) {
+    return false;
+  }
+  const {
+    source,
+    target
+  } = edge;
+  const sourceAdjacency = mutable.adjacency.get(source);
+  if (sourceAdjacency !== void 0) {
+    const index = sourceAdjacency.indexOf(edgeIndex);
+    if (index !== -1) {
+      sourceAdjacency.splice(index, 1);
+    }
+  }
+  const targetReverseAdjacency = mutable.reverseAdjacency.get(target);
+  if (targetReverseAdjacency !== void 0) {
+    const index = targetReverseAdjacency.indexOf(edgeIndex);
+    if (index !== -1) {
+      targetReverseAdjacency.splice(index, 1);
+    }
+  }
+  if (mutable.type === "undirected") {
+    const targetAdjacency = mutable.adjacency.get(target);
+    if (targetAdjacency !== void 0) {
+      const index = targetAdjacency.indexOf(edgeIndex);
+      if (index !== -1) {
+        targetAdjacency.splice(index, 1);
+      }
+    }
+    const sourceReverseAdjacency = mutable.reverseAdjacency.get(source);
+    if (sourceReverseAdjacency !== void 0) {
+      const index = sourceReverseAdjacency.indexOf(edgeIndex);
+      if (index !== -1) {
+        sourceReverseAdjacency.splice(index, 1);
+      }
+    }
+  }
+  mutable.edges.delete(edgeIndex);
+  return true;
+};
+var neighborsDirected = (graph, nodeIndex, direction) => {
+  const adjacencyMap = direction === "incoming" ? graph.reverseAdjacency : graph.adjacency;
+  const adjacencyList = adjacencyMap.get(nodeIndex);
+  if (adjacencyList === void 0) {
+    return [];
+  }
+  const result = [];
+  for (const edgeIndex of adjacencyList) {
+    const edge = graph.edges.get(edgeIndex);
+    if (edge !== void 0) {
+      const neighborNode = direction === "incoming" ? edge.source : edge.target;
+      result.push(neighborNode);
+    }
+  }
+  return result;
+};
+var escapeMermaidLabel = (label) => {
+  return label.replace(/#/g, "#35;").replace(/"/g, "#quot;").replace(/</g, "#lt;").replace(/>/g, "#gt;").replace(/&/g, "#amp;").replace(/\[/g, "#91;").replace(/\]/g, "#93;").replace(/\{/g, "#123;").replace(/\}/g, "#125;").replace(/\(/g, "#40;").replace(/\)/g, "#41;").replace(/\|/g, "#124;").replace(/\\/g, "#92;").replace(/\n/g, "<br/>");
+};
+var formatMermaidNode = (nodeId, label, shape) => {
+  switch (shape) {
+    case "rectangle":
+      return `${nodeId}["${label}"]`;
+    case "rounded":
+      return `${nodeId}("${label}")`;
+    case "circle":
+      return `${nodeId}(("${label}"))`;
+    case "diamond":
+      return `${nodeId}{"${label}"}`;
+    case "hexagon":
+      return `${nodeId}{{"${label}"}}`;
+    case "stadium":
+      return `${nodeId}(["${label}"])`;
+    case "subroutine":
+      return `${nodeId}[["${label}"]]`;
+    case "cylindrical":
+      return `${nodeId}[("${label}")]`;
+  }
+};
+var toMermaid = (graph, options) => {
+  const {
+    diagramType,
+    direction = "TD",
+    edgeLabel = (data) => String(data),
+    nodeLabel = (data) => String(data),
+    nodeShape = () => "rectangle"
+  } = options ?? {};
+  const finalDiagramType = diagramType ?? (graph.type === "directed" ? "flowchart" : "graph");
+  const lines = [];
+  lines.push(`${finalDiagramType} ${direction}`);
+  for (const [nodeIndex, nodeData] of graph.nodes) {
+    const nodeId = String(nodeIndex);
+    const label = escapeMermaidLabel(nodeLabel(nodeData));
+    const shape = nodeShape(nodeData);
+    const formattedNode = formatMermaidNode(nodeId, label, shape);
+    lines.push(`  ${formattedNode}`);
+  }
+  const edgeOperator = finalDiagramType === "flowchart" ? "-->" : "---";
+  for (const [, edgeData] of graph.edges) {
+    const sourceId = String(edgeData.source);
+    const targetId = String(edgeData.target);
+    const label = escapeMermaidLabel(edgeLabel(edgeData.data));
+    if (label) {
+      lines.push(`  ${sourceId} ${edgeOperator}|"${label}"| ${targetId}`);
+    } else {
+      lines.push(`  ${sourceId} ${edgeOperator} ${targetId}`);
+    }
+  }
+  return lines.join("\n");
+};
+var Walker = class {
+  // @ts-ignore
+  [Symbol.iterator];
+  /**
+   * Visits each element and maps it to a value using the provided function.
+   *
+   * Takes a function that receives the index and data,
+   * and returns an iterable of the mapped values. Skips elements that
+   * no longer exist in the graph.
+   *
+   * @example
+   * ```ts
+   * import { Graph } from "effect"
+   *
+   * const graph = Graph.directed<string, number>((mutable) => {
+   *   const a = Graph.addNode(mutable, "A")
+   *   const b = Graph.addNode(mutable, "B")
+   *   Graph.addEdge(mutable, a, b, 1)
+   * })
+   *
+   * const dfs = Graph.dfs(graph, { start: [0] })
+   *
+   * // Map to just the node data
+   * const values = Array.from(dfs.visit((index, data) => data))
+   * console.log(values) // ["A", "B"]
+   *
+   * // Map to custom objects
+   * const custom = Array.from(dfs.visit((index, data) => ({ id: index, name: data })))
+   * console.log(custom) // [{ id: 0, name: "A" }, { id: 1, name: "B" }]
+   * ```
+   *
+   * @since 3.18.0
+   * @category iterators
+   */
+  visit;
+  constructor(visit) {
+    this.visit = visit;
+    this[Symbol.iterator] = visit((index, data) => [index, data])[Symbol.iterator];
+  }
+};
+var indices = (walker) => walker.visit((index, _) => index);
+var values2 = (walker) => walker.visit((_, data) => data);
+var entries = (walker) => walker.visit((index, data) => [index, data]);
+var dfsPostOrder = (graph, config = {}) => {
+  const start = config.start ?? [];
+  const direction = config.direction ?? "outgoing";
+  for (const nodeIndex of start) {
+    if (!hasNode(graph, nodeIndex)) {
+      throw missingNode(nodeIndex);
+    }
+  }
+  return new Walker((f) => ({
+    [Symbol.iterator]: () => {
+      const stack = [];
+      const discovered = /* @__PURE__ */ new Set();
+      const finished = /* @__PURE__ */ new Set();
+      for (let i = start.length - 1; i >= 0; i--) {
+        stack.push({
+          node: start[i],
+          visitedChildren: false
+        });
+      }
+      const nextMapped = () => {
+        while (stack.length > 0) {
+          const current = stack[stack.length - 1];
+          if (!discovered.has(current.node)) {
+            discovered.add(current.node);
+            current.visitedChildren = false;
+          }
+          if (!current.visitedChildren) {
+            current.visitedChildren = true;
+            const neighbors = neighborsDirected(graph, current.node, direction);
+            for (let i = neighbors.length - 1; i >= 0; i--) {
+              const neighbor = neighbors[i];
+              if (!discovered.has(neighbor) && !finished.has(neighbor)) {
+                stack.push({
+                  node: neighbor,
+                  visitedChildren: false
+                });
+              }
+            }
+          } else {
+            const nodeToEmit = stack.pop().node;
+            if (!finished.has(nodeToEmit)) {
+              finished.add(nodeToEmit);
+              const nodeData = getNode(graph, nodeToEmit);
+              if (isSome2(nodeData)) {
+                return {
+                  done: false,
+                  value: f(nodeToEmit, nodeData.value)
+                };
+              }
+              return nextMapped();
+            }
+          }
+        }
+        return {
+          done: true,
+          value: void 0
+        };
+      };
+      return {
+        next: nextMapped
+      };
+    }
+  }));
+};
+var nodes = (graph) => new Walker((f) => ({
+  [Symbol.iterator]() {
+    const nodeMap = graph.nodes;
+    const iterator = nodeMap.entries();
+    return {
+      next() {
+        const result = iterator.next();
+        if (result.done) {
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        const [nodeIndex, nodeData] = result.value;
+        return {
+          done: false,
+          value: f(nodeIndex, nodeData)
+        };
+      }
+    };
+  }
+}));
+var edges = (graph) => new Walker((f) => ({
+  [Symbol.iterator]() {
+    const edgeMap = graph.edges;
+    const iterator = edgeMap.entries();
+    return {
+      next() {
+        const result = iterator.next();
+        if (result.done) {
+          return {
+            done: true,
+            value: void 0
+          };
+        }
+        const [edgeIndex, edgeData] = result.value;
+        return {
+          done: false,
+          value: f(edgeIndex, edgeData)
+        };
+      }
+    };
   }
-  return result;
+}));
+var externals = (graph, config = {}) => {
+  const direction = config.direction ?? "outgoing";
+  return new Walker((f) => ({
+    [Symbol.iterator]: () => {
+      const nodeMap = graph.nodes;
+      const adjacencyMap = direction === "incoming" ? graph.reverseAdjacency : graph.adjacency;
+      const nodeIterator = nodeMap.entries();
+      const nextMapped = () => {
+        let current = nodeIterator.next();
+        while (!current.done) {
+          const [nodeIndex, nodeData] = current.value;
+          const adjacencyList = adjacencyMap.get(nodeIndex);
+          if (adjacencyList === void 0 || adjacencyList.length === 0) {
+            return {
+              done: false,
+              value: f(nodeIndex, nodeData)
+            };
+          }
+          current = nodeIterator.next();
+        }
+        return {
+          done: true,
+          value: void 0
+        };
+      };
+      return {
+        next: nextMapped
+      };
+    }
+  }));
 };
-var base64abc = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "+", "/"];
-
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/internal/encoding/base64Url.js
-var encode2 = (data) => encode(data).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
-
-// node_modules/.pnpm/effect@3.18.4/node_modules/effect/dist/esm/Encoding.js
-var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
 
 // src/diagnostics/classSelfMismatch.ts
 var classSelfMismatch = createDiagnostic({
@@ -4373,8 +6628,8 @@ var effectInVoidSuccess = createDiagnostic({
       }
       return yield* fail(typeParserIssue("expectedEffect success is not void"));
     });
-    const entries = typeCheckerUtils.expectedAndRealType(sourceFile);
-    for (const [node, expectedType, valueNode, realType] of entries) {
+    const entries2 = typeCheckerUtils.expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries2) {
       if (expectedType !== realType) {
         yield* pipe(
           checkForEffectInVoid(
@@ -4794,8 +7049,8 @@ var missingEffectContext = createDiagnostic({
       )
     );
     const sortTypes = sort(typeCheckerUtils.deterministicTypeOrder);
-    const entries = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
-    for (const [node, expectedType, valueNode, realType] of entries) {
+    const entries2 = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries2) {
       if (expectedType !== realType) {
         yield* pipe(
           checkForMissingContextTypes(
@@ -4860,8 +7115,8 @@ var missingEffectError = createDiagnostic({
       )
     );
     const sortTypes = sort(typeCheckerUtils.deterministicTypeOrder);
-    const entries = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
-    for (const [node, expectedType, valueNode, realType] of entries) {
+    const entries2 = getEffectLspPatchSourceFileMetadata(sourceFile)?.relationErrors || typeCheckerUtils.expectedAndRealType(sourceFile);
+    for (const [node, expectedType, valueNode, realType] of entries2) {
       if (expectedType !== realType) {
         yield* pipe(
           checkForMissingErrorTypes(
@@ -5625,9 +7880,9 @@ var scopeInLayerEffect = createDiagnostic({
       return { methodIdentifier };
     }
     const reportIfLayerRequireScope = (type, node, methodIdentifier) => {
-      const entries = typeCheckerUtils.unrollUnionMembers(type);
+      const entries2 = typeCheckerUtils.unrollUnionMembers(type);
       return pipe(
-        firstSuccessOf(entries.map((type2) => typeParser.scopeType(type2, node))),
+        firstSuccessOf(entries2.map((type2) => typeParser.scopeType(type2, node))),
         map5(
           () => report({
             location: node,
@@ -5708,29 +7963,29 @@ var strictBooleanExpressions = createDiagnostic({
     while (nodeToVisit.length > 0) {
       const node = nodeToVisit.shift();
       ts.forEachChild(node, appendNodeToVisit);
-      const nodes = [];
+      const nodes2 = [];
       if (ts.isIfStatement(node)) {
         conditionChecks.set(node, true);
-        nodes.push(node.expression);
+        nodes2.push(node.expression);
       } else if (ts.isWhileStatement(node)) {
         conditionChecks.set(node, true);
-        nodes.push(node.expression);
+        nodes2.push(node.expression);
       } else if (ts.isConditionalExpression(node)) {
         conditionChecks.set(node, true);
-        nodes.push(node.condition);
+        nodes2.push(node.condition);
       } else if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
         conditionChecks.set(node, true);
-        nodes.push(node.operand);
+        nodes2.push(node.operand);
       } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
         if (conditionChecks.has(node.parent)) conditionChecks.set(node, true);
-        nodes.push(node.left);
-        nodes.push(node.right);
+        nodes2.push(node.left);
+        nodes2.push(node.right);
       } else if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) {
         if (conditionChecks.has(node.parent)) conditionChecks.set(node, true);
-        nodes.push(node.left);
-        nodes.push(node.right);
+        nodes2.push(node.left);
+        nodes2.push(node.right);
       }
-      for (const nodeToCheck of nodes) {
+      for (const nodeToCheck of nodes2) {
         if (!nodeToCheck) continue;
         if (!conditionChecks.has(nodeToCheck.parent)) continue;
         const nodeType = typeChecker.getTypeAtLocation(nodeToCheck);
@@ -6055,9 +8310,9 @@ var effectDiagnosticsComment = createCompletion({
   apply: fn("effectDiagnosticsComment")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const sourceText = sourceFile.text;
-    const match2 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
-    if (match2 && match2.indices) {
-      const lastIndex = match2.indices[2][0];
+    const match3 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
+    if (match3 && match3.indices) {
+      const lastIndex = match3.indices[2][0];
       const replacementSpan = {
         start: lastIndex,
         length: Math.max(0, position - lastIndex)
@@ -6088,9 +8343,9 @@ var effectJsdocComment = createCompletion({
   apply: fn("effectJsdocComment")(function* (sourceFile, position) {
     const ts = yield* service(TypeScriptApi);
     const sourceText = sourceFile.text;
-    const match2 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
-    if (match2 && match2.indices) {
-      const lastIndex = match2.indices[2][0];
+    const match3 = /(\/\/|\/\*(?:\*?))\s*(@)\s*$/id.exec(sourceText.substring(0, position));
+    if (match3 && match3.indices) {
+      const lastIndex = match3.indices[2][0];
       const replacementSpan = {
         start: lastIndex,
         length: Math.max(0, position - lastIndex)
@@ -8085,10 +10340,10 @@ var putShortMSB = (s, b) => {
   s.pending_buf[s.pending++] = b >>> 8 & 255;
   s.pending_buf[s.pending++] = b & 255;
 };
-var read_buf = (strm, buf, start, size) => {
+var read_buf = (strm, buf, start, size4) => {
   let len = strm.avail_in;
-  if (len > size) {
-    len = size;
+  if (len > size4) {
+    len = size4;
   }
   if (len === 0) {
     return 0;
@@ -8107,7 +10362,7 @@ var read_buf = (strm, buf, start, size) => {
 var longest_match = (s, cur_match) => {
   let chain_length = s.max_chain_length;
   let scan = s.strstart;
-  let match2;
+  let match3;
   let len;
   let best_len = s.prev_length;
   let nice_match = s.nice_match;
@@ -8125,14 +10380,14 @@ var longest_match = (s, cur_match) => {
     nice_match = s.lookahead;
   }
   do {
-    match2 = cur_match;
-    if (_win[match2 + best_len] !== scan_end || _win[match2 + best_len - 1] !== scan_end1 || _win[match2] !== _win[scan] || _win[++match2] !== _win[scan + 1]) {
+    match3 = cur_match;
+    if (_win[match3 + best_len] !== scan_end || _win[match3 + best_len - 1] !== scan_end1 || _win[match3] !== _win[scan] || _win[++match3] !== _win[scan + 1]) {
       continue;
     }
     scan += 2;
-    match2++;
+    match3++;
     do {
-    } while (_win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && _win[++scan] === _win[++match2] && scan < strend);
+    } while (_win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && _win[++scan] === _win[++match3] && scan < strend);
     len = MAX_MATCH - (strend - scan);
     scan = strend - MAX_MATCH;
     if (len > best_len) {
@@ -8710,11 +10965,11 @@ var deflateReset = (strm) => {
   }
   return ret;
 };
-var deflateSetHeader = (strm, head2) => {
+var deflateSetHeader = (strm, head3) => {
   if (deflateStateCheck(strm) || strm.state.wrap !== 2) {
     return Z_STREAM_ERROR$2;
   }
-  strm.state.gzhead = head2;
+  strm.state.gzhead = head3;
   return Z_OK$3;
 };
 var deflateInit2 = (strm, level, method, windowBits, memLevel, strategy) => {
@@ -8868,20 +11123,20 @@ var deflate$2 = (strm, flush) => {
       let beg = s.pending;
       let left3 = (s.gzhead.extra.length & 65535) - s.gzindex;
       while (s.pending + left3 > s.pending_buf_size) {
-        let copy = s.pending_buf_size - s.pending;
-        s.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy), s.pending);
+        let copy2 = s.pending_buf_size - s.pending;
+        s.pending_buf.set(s.gzhead.extra.subarray(s.gzindex, s.gzindex + copy2), s.pending);
         s.pending = s.pending_buf_size;
         if (s.gzhead.hcrc && s.pending > beg) {
           strm.adler = crc32_1(strm.adler, s.pending_buf, s.pending - beg, beg);
         }
-        s.gzindex += copy;
+        s.gzindex += copy2;
         flush_pending(strm);
         if (s.pending !== 0) {
           s.last_flush = -1;
           return Z_OK$3;
         }
         beg = 0;
-        left3 -= copy;
+        left3 -= copy2;
       }
       let gzhead_extra = new Uint8Array(s.gzhead.extra);
       s.pending_buf.set(gzhead_extra.subarray(s.gzindex, s.gzindex + left3), s.pending);
@@ -9833,7 +12088,7 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   let mask;
   let next;
   let base = null;
-  let match2;
+  let match3;
   const count = new Uint16Array(MAXBITS + 1);
   const offs = new Uint16Array(MAXBITS + 1);
   let extra = null;
@@ -9889,15 +12144,15 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   }
   if (type === CODES$1) {
     base = extra = work;
-    match2 = 20;
+    match3 = 20;
   } else if (type === LENS$1) {
     base = lbase;
     extra = lext;
-    match2 = 257;
+    match3 = 257;
   } else {
     base = dbase;
     extra = dext;
-    match2 = 0;
+    match3 = 0;
   }
   huff = 0;
   sym = 0;
@@ -9913,12 +12168,12 @@ var inflate_table = (type, lens, lens_index, codes, table, table_index, work, op
   }
   for (; ; ) {
     here_bits = len - drop;
-    if (work[sym] + 1 < match2) {
+    if (work[sym] + 1 < match3) {
       here_op = 0;
       here_val = work[sym];
-    } else if (work[sym] >= match2) {
-      here_op = extra[work[sym] - match2];
-      here_val = base[work[sym] - match2];
+    } else if (work[sym] >= match3) {
+      here_op = extra[work[sym] - match3];
+      here_val = base[work[sym] - match3];
     } else {
       here_op = 32 + 64;
       here_val = 0;
@@ -10190,7 +12445,7 @@ var fixedtables = (state) => {
   state.distcode = distfix;
   state.distbits = 5;
 };
-var updatewindow = (strm, src, end, copy) => {
+var updatewindow = (strm, src, end, copy2) => {
   let dist;
   const state = strm.state;
   if (state.window === null) {
@@ -10199,20 +12454,20 @@ var updatewindow = (strm, src, end, copy) => {
     state.whave = 0;
     state.window = new Uint8Array(state.wsize);
   }
-  if (copy >= state.wsize) {
+  if (copy2 >= state.wsize) {
     state.window.set(src.subarray(end - state.wsize, end), 0);
     state.wnext = 0;
     state.whave = state.wsize;
   } else {
     dist = state.wsize - state.wnext;
-    if (dist > copy) {
-      dist = copy;
-    }
-    state.window.set(src.subarray(end - copy, end - copy + dist), state.wnext);
-    copy -= dist;
-    if (copy) {
-      state.window.set(src.subarray(end - copy, end), 0);
-      state.wnext = copy;
+    if (dist > copy2) {
+      dist = copy2;
+    }
+    state.window.set(src.subarray(end - copy2, end - copy2 + dist), state.wnext);
+    copy2 -= dist;
+    if (copy2) {
+      state.window.set(src.subarray(end - copy2, end), 0);
+      state.wnext = copy2;
       state.whave = state.wsize;
     } else {
       state.wnext += dist;
@@ -10235,7 +12490,7 @@ var inflate$2 = (strm, flush) => {
   let hold;
   let bits;
   let _in, _out;
-  let copy;
+  let copy2;
   let from;
   let from_source;
   let here = 0;
@@ -10434,11 +12689,11 @@ var inflate$2 = (strm, flush) => {
         /* falls through */
         case EXTRA:
           if (state.flags & 1024) {
-            copy = state.length;
-            if (copy > have) {
-              copy = have;
+            copy2 = state.length;
+            if (copy2 > have) {
+              copy2 = have;
             }
-            if (copy) {
+            if (copy2) {
               if (state.head) {
                 len = state.head.extra_len - state.length;
                 if (!state.head.extra) {
@@ -10449,18 +12704,18 @@ var inflate$2 = (strm, flush) => {
                     next,
                     // extra field is limited to 65536 bytes
                     // - no need for additional size check
-                    next + copy
+                    next + copy2
                   ),
                   /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
                   len
                 );
               }
               if (state.flags & 512 && state.wrap & 4) {
-                state.check = crc32_1(state.check, input, copy, next);
+                state.check = crc32_1(state.check, input, copy2, next);
               }
-              have -= copy;
-              next += copy;
-              state.length -= copy;
+              have -= copy2;
+              next += copy2;
+              state.length -= copy2;
             }
             if (state.length) {
               break inf_leave;
@@ -10474,18 +12729,18 @@ var inflate$2 = (strm, flush) => {
             if (have === 0) {
               break inf_leave;
             }
-            copy = 0;
+            copy2 = 0;
             do {
-              len = input[next + copy++];
+              len = input[next + copy2++];
               if (state.head && len && state.length < 65536) {
                 state.head.name += String.fromCharCode(len);
               }
-            } while (len && copy < have);
+            } while (len && copy2 < have);
             if (state.flags & 512 && state.wrap & 4) {
-              state.check = crc32_1(state.check, input, copy, next);
+              state.check = crc32_1(state.check, input, copy2, next);
             }
-            have -= copy;
-            next += copy;
+            have -= copy2;
+            next += copy2;
             if (len) {
               break inf_leave;
             }
@@ -10500,18 +12755,18 @@ var inflate$2 = (strm, flush) => {
             if (have === 0) {
               break inf_leave;
             }
-            copy = 0;
+            copy2 = 0;
             do {
-              len = input[next + copy++];
+              len = input[next + copy2++];
               if (state.head && len && state.length < 65536) {
                 state.head.comment += String.fromCharCode(len);
               }
-            } while (len && copy < have);
+            } while (len && copy2 < have);
             if (state.flags & 512 && state.wrap & 4) {
-              state.check = crc32_1(state.check, input, copy, next);
+              state.check = crc32_1(state.check, input, copy2, next);
             }
-            have -= copy;
-            next += copy;
+            have -= copy2;
+            next += copy2;
             if (len) {
               break inf_leave;
             }
@@ -10646,23 +12901,23 @@ var inflate$2 = (strm, flush) => {
           state.mode = COPY;
         /* falls through */
         case COPY:
-          copy = state.length;
-          if (copy) {
-            if (copy > have) {
-              copy = have;
+          copy2 = state.length;
+          if (copy2) {
+            if (copy2 > have) {
+              copy2 = have;
             }
-            if (copy > left3) {
-              copy = left3;
+            if (copy2 > left3) {
+              copy2 = left3;
             }
-            if (copy === 0) {
+            if (copy2 === 0) {
               break inf_leave;
             }
-            output.set(input.subarray(next, next + copy), put);
-            have -= copy;
-            next += copy;
-            left3 -= copy;
-            put += copy;
-            state.length -= copy;
+            output.set(input.subarray(next, next + copy2), put);
+            have -= copy2;
+            next += copy2;
+            left3 -= copy2;
+            put += copy2;
+            state.length -= copy2;
             break;
           }
           state.mode = TYPE;
@@ -10763,7 +13018,7 @@ var inflate$2 = (strm, flush) => {
                   break;
                 }
                 len = state.lens[state.have - 1];
-                copy = 3 + (hold & 3);
+                copy2 = 3 + (hold & 3);
                 hold >>>= 2;
                 bits -= 2;
               } else if (here_val === 17) {
@@ -10779,7 +13034,7 @@ var inflate$2 = (strm, flush) => {
                 hold >>>= here_bits;
                 bits -= here_bits;
                 len = 0;
-                copy = 3 + (hold & 7);
+                copy2 = 3 + (hold & 7);
                 hold >>>= 3;
                 bits -= 3;
               } else {
@@ -10795,16 +13050,16 @@ var inflate$2 = (strm, flush) => {
                 hold >>>= here_bits;
                 bits -= here_bits;
                 len = 0;
-                copy = 11 + (hold & 127);
+                copy2 = 11 + (hold & 127);
                 hold >>>= 7;
                 bits -= 7;
               }
-              if (state.have + copy > state.nlen + state.ndist) {
+              if (state.have + copy2 > state.nlen + state.ndist) {
                 strm.msg = "invalid bit length repeat";
                 state.mode = BAD;
                 break;
               }
-              while (copy--) {
+              while (copy2--) {
                 state.lens[state.have++] = len;
               }
             }
@@ -11023,39 +13278,39 @@ var inflate$2 = (strm, flush) => {
           if (left3 === 0) {
             break inf_leave;
           }
-          copy = _out - left3;
-          if (state.offset > copy) {
-            copy = state.offset - copy;
-            if (copy > state.whave) {
+          copy2 = _out - left3;
+          if (state.offset > copy2) {
+            copy2 = state.offset - copy2;
+            if (copy2 > state.whave) {
               if (state.sane) {
                 strm.msg = "invalid distance too far back";
                 state.mode = BAD;
                 break;
               }
             }
-            if (copy > state.wnext) {
-              copy -= state.wnext;
-              from = state.wsize - copy;
+            if (copy2 > state.wnext) {
+              copy2 -= state.wnext;
+              from = state.wsize - copy2;
             } else {
-              from = state.wnext - copy;
+              from = state.wnext - copy2;
             }
-            if (copy > state.length) {
-              copy = state.length;
+            if (copy2 > state.length) {
+              copy2 = state.length;
             }
             from_source = state.window;
           } else {
             from_source = output;
             from = put - state.offset;
-            copy = state.length;
+            copy2 = state.length;
           }
-          if (copy > left3) {
-            copy = left3;
+          if (copy2 > left3) {
+            copy2 = left3;
           }
-          left3 -= copy;
-          state.length -= copy;
+          left3 -= copy2;
+          state.length -= copy2;
           do {
             output[put++] = from_source[from++];
-          } while (--copy);
+          } while (--copy2);
           if (state.length === 0) {
             state.mode = LEN;
           }
@@ -11165,7 +13420,7 @@ var inflateEnd = (strm) => {
   strm.state = null;
   return Z_OK$1;
 };
-var inflateGetHeader = (strm, head2) => {
+var inflateGetHeader = (strm, head3) => {
   if (inflateStateCheck(strm)) {
     return Z_STREAM_ERROR$1;
   }
@@ -11173,8 +13428,8 @@ var inflateGetHeader = (strm, head2) => {
   if ((state.wrap & 2) === 0) {
     return Z_STREAM_ERROR$1;
   }
-  state.head = head2;
-  head2.done = false;
+  state.head = head3;
+  head3.done = false;
   return Z_OK$1;
 };
 var inflateSetDictionary = (strm, dictionary) => {
@@ -11412,7 +13667,7 @@ var { Deflate, deflate, deflateRaw, gzip } = deflate_1$1;
 var { Inflate, inflate, inflateRaw, ungzip } = inflate_1$1;
 var deflate_1 = deflate;
 
-// src/quickinfo/layerInfo.ts
+// src/core/LayerGraph.ts
 var UnableToProduceLayerGraphError = class {
   constructor(message, node) {
     this.message = message;
@@ -11420,250 +13675,419 @@ var UnableToProduceLayerGraphError = class {
   }
   _tag = "@effect/language-service/UnableToProduceLayerGraphError";
 };
-var GraphNodeLeaf = class {
-  constructor(id, node, rout, rin) {
-    this.id = id;
-    this.node = node;
-    this.rout = rout;
-    this.rin = rin;
-  }
-  _tag = "GraphNodeLeaf";
-};
-var GraphNodeCompoundTransform = class {
-  constructor(id, node, args2, rout, rin) {
-    this.id = id;
-    this.node = node;
-    this.args = args2;
-    this.rout = rout;
-    this.rin = rin;
-  }
-  _tag = "GraphNodeCompoundTransform";
-};
-function processLayerGraphNode(ctx, node, pipedInGraphNode) {
-  return gen(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    const typeParser = yield* service(TypeParser);
-    const typeCheckerUtils = yield* service(TypeCheckerUtils);
-    const excludeNever = (type) => succeed((type.flags & ts.TypeFlags.Never) !== 0);
-    const maybePipe = yield* option(typeParser.pipeCall(node));
-    if (isSome2(maybePipe)) {
-      let graphNode = yield* processLayerGraphNode(ctx, maybePipe.value.subject, void 0);
-      for (const entry of maybePipe.value.args) {
-        graphNode = yield* processLayerGraphNode(ctx, entry, graphNode);
+var extractLayerGraph = fn("extractLayerGraph")(function* (node, opts) {
+  const ts = yield* service(TypeScriptApi);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const typeParser = yield* service(TypeParser);
+  const typeCheckerUtils = yield* service(TypeCheckerUtils);
+  const tsUtils = yield* service(TypeScriptUtils);
+  const sourceFile = tsUtils.getSourceFileOfNode(node);
+  const layerModuleName = tsUtils.findImportedModuleIdentifierByPackageAndNameOrBarrel(sourceFile, "effect", "Layer") || "Layer";
+  const visitedNodes = /* @__PURE__ */ new WeakSet();
+  const nodeInPipeContext = /* @__PURE__ */ new WeakSet();
+  const nodeToGraph = /* @__PURE__ */ new WeakMap();
+  const nodeToVisit = [node];
+  const appendNodeToVisit = (node2) => {
+    nodeToVisit.push(node2);
+    return void 0;
+  };
+  const mutableGraph = beginMutation3(directed());
+  const extractNodeInfo = fn("extractNodeInfo")(function* (node2) {
+    let provides = [];
+    let requires = [];
+    let layerType = void 0;
+    let layerTypes = void 0;
+    if (nodeInPipeContext.has(node2)) {
+      if (ts.isExpression(node2)) {
+        const contextualType = typeChecker.getContextualType(node2);
+        if (contextualType) {
+          const callSignatures = typeChecker.getSignaturesOfType(contextualType, ts.SignatureKind.Call);
+          if (callSignatures.length === 1) {
+            layerType = typeChecker.getReturnTypeOfSignature(callSignatures[0]);
+          }
+        }
       }
-      return graphNode;
+    } else {
+      layerType = typeChecker.getTypeAtLocation(node2);
     }
-    if (ts.isCallExpression(node)) {
-      const type = typeChecker.getTypeAtLocation(node);
-      const maybeLayer = yield* option(typeParser.layerType(type, node));
-      if (isSome2(maybeLayer)) {
-        const argNodes = yield* option(
-          all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+    if (layerType) {
+      layerTypes = yield* pipe(typeParser.layerType(layerType, node2), orElse2(() => void_));
+    }
+    if (!layerTypes) layerType = void 0;
+    if (layerTypes) {
+      provides = typeCheckerUtils.unrollUnionMembers(layerTypes.ROut).filter((_) => !(_.flags & ts.TypeFlags.Never));
+      requires = typeCheckerUtils.unrollUnionMembers(layerTypes.RIn).filter((_) => !(_.flags & ts.TypeFlags.Never));
+    }
+    return { node: node2, layerType, layerTypes, provides, requires };
+  });
+  const addNode2 = fn("addNode")(function* (node2, nodeInfo) {
+    const graphNode = addNode(mutableGraph, nodeInfo ? nodeInfo : yield* extractNodeInfo(node2));
+    nodeToGraph.set(node2, graphNode);
+    return graphNode;
+  });
+  while (nodeToVisit.length > 0) {
+    const node2 = nodeToVisit.pop();
+    const pipeArgs = yield* pipe(typeParser.pipeCall(node2), orElse2(() => void_));
+    if (pipeArgs) {
+      if (!visitedNodes.has(node2)) {
+        appendNodeToVisit(node2);
+        appendNodeToVisit(pipeArgs.subject);
+        pipeArgs.args.forEach(appendNodeToVisit);
+        pipeArgs.args.forEach((_) => nodeInPipeContext.add(_));
+        visitedNodes.add(node2);
+      } else {
+        const childNodes = [pipeArgs.subject, ...pipeArgs.args].map((_) => nodeToGraph.get(_)).filter(
+          isNumber
+        ).filter(
+          (_) => hasNode(mutableGraph, _)
         );
-        if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
-          const { allIndexes: outTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-            ctx.services,
-            maybeLayer.value.ROut,
-            excludeNever
-          );
-          const { allIndexes: inTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-            ctx.services,
-            maybeLayer.value.RIn,
-            excludeNever
-          );
-          return new GraphNodeCompoundTransform(
-            ctx.nextId(),
-            node,
-            argNodes.value,
-            outTypes,
-            inTypes
-          );
+        if (childNodes.length === pipeArgs.args.length + 1) {
+          let lastNode = null;
+          for (const childNode of childNodes) {
+            if (lastNode !== null) addEdge(mutableGraph, childNode, lastNode, { relationship: "pipe" });
+            lastNode = childNode;
+          }
+          if (lastNode !== null) {
+            const graphNode = yield* addNode2(node2);
+            addEdge(mutableGraph, graphNode, lastNode, { relationship: "pipe" });
+          }
+        } else {
+          childNodes.forEach((_) => removeNode(mutableGraph, _));
+          const nodeInfo = yield* extractNodeInfo(node2);
+          if (nodeInfo.layerTypes) yield* addNode2(node2, nodeInfo);
         }
       }
+      continue;
     }
-    if (pipedInGraphNode && ts.isExpression(node)) {
-      const type = typeChecker.getContextualType(node);
-      if (type) {
-        const callSignatures = typeChecker.getSignaturesOfType(type, ts.SignatureKind.Call);
-        if (callSignatures.length === 1) {
-          const [signature] = callSignatures;
-          const returnType = typeChecker.getReturnTypeOfSignature(signature);
-          const maybeLayer = yield* option(typeParser.layerType(returnType, node));
-          if (isSome2(maybeLayer)) {
-            const { allIndexes: outTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-              ctx.services,
-              maybeLayer.value.ROut,
-              excludeNever
-            );
-            const { allIndexes: inTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-              ctx.services,
-              maybeLayer.value.RIn,
-              excludeNever
+    if (ts.isCallExpression(node2)) {
+      let shouldExplode = !opts.explodeOnlyLayerCalls;
+      if (opts.explodeOnlyLayerCalls) {
+        const isLayerCall = ts.isPropertyAccessExpression(node2.expression) && ts.isIdentifier(node2.expression.expression) && ts.idText(node2.expression.expression) === layerModuleName;
+        if (isLayerCall) shouldExplode = true;
+      }
+      if (shouldExplode) {
+        if (!visitedNodes.has(node2)) {
+          appendNodeToVisit(node2);
+          node2.arguments.forEach(appendNodeToVisit);
+          visitedNodes.add(node2);
+        } else {
+          const childNodes = node2.arguments.map((_) => nodeToGraph.get(_)).filter(isNumber).filter(
+            (_) => hasNode(mutableGraph, _)
+          );
+          if (childNodes.length === node2.arguments.length) {
+            const graphNode = yield* addNode2(node2);
+            childNodes.forEach(
+              (_, argumentIndex) => addEdge(mutableGraph, graphNode, _, { relationship: "call", argumentIndex })
             );
-            if (ts.isCallExpression(node)) {
-              const argNodes = yield* option(
-                all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
-              );
-              if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
-                return new GraphNodeCompoundTransform(
-                  ctx.nextId(),
-                  node,
-                  [pipedInGraphNode, ...argNodes.value],
-                  outTypes,
-                  inTypes
-                );
-              }
-            }
-            const argNode = yield* option(processLayerGraphNode(ctx, node, void 0));
-            if (isSome2(argNode)) {
-              return new GraphNodeCompoundTransform(
-                ctx.nextId(),
-                node,
-                [pipedInGraphNode, argNode.value],
-                outTypes,
-                inTypes
-              );
-            } else {
-              return new GraphNodeCompoundTransform(
-                ctx.nextId(),
-                node,
-                [pipedInGraphNode],
-                outTypes,
-                inTypes
-              );
-            }
+          } else {
+            childNodes.forEach((_) => removeNode(mutableGraph, _));
+            const nodeInfo = yield* extractNodeInfo(node2);
+            if (nodeInfo.layerTypes) yield* addNode2(node2, nodeInfo);
           }
         }
+        continue;
       }
     }
-    if (ts.isExpression(node)) {
-      const type = typeChecker.getTypeAtLocation(node);
-      const maybeLayer = yield* option(typeParser.layerType(type, node));
-      if (isSome2(maybeLayer)) {
-        const { allIndexes: outTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-          ctx.services,
-          maybeLayer.value.ROut,
-          excludeNever
-        );
-        const { allIndexes: inTypes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-          ctx.services,
-          maybeLayer.value.RIn,
-          excludeNever
+    if (opts.arrayLiteralAsMerge && ts.isArrayLiteralExpression(node2)) {
+      if (!visitedNodes.has(node2)) {
+        appendNodeToVisit(node2);
+        node2.elements.forEach(appendNodeToVisit);
+        visitedNodes.add(node2);
+      } else {
+        const childNodes = node2.elements.map((_) => nodeToGraph.get(_)).filter(isNumber).filter(
+          (_) => hasNode(mutableGraph, _)
         );
-        return new GraphNodeLeaf(ctx.nextId(), node, outTypes, inTypes);
+        if (childNodes.length > 0) {
+          const graphNode = yield* addNode2(node2);
+          childNodes.forEach(
+            (_, index) => addEdge(mutableGraph, graphNode, _, { relationship: "arrayLiteral", index })
+          );
+        }
       }
+      continue;
     }
-    const nodeText = node.getText().trim().substr(0, 20);
-    return yield* fail(new UnableToProduceLayerGraphError(nodeText));
-  });
-}
-function findInnermostGraphEdge(graph, kind, key) {
-  switch (graph._tag) {
-    case "GraphNodeLeaf":
-      return graph[kind].indexOf(key) > -1 ? [graph] : [];
-    case "GraphNodeCompoundTransform": {
-      if (graph[kind].indexOf(key) > -1) {
-        let result = [];
-        for (const child of graph.args) {
-          result = result.concat(findInnermostGraphEdge(child, kind, key));
-        }
-        if (result.length > 0) return result;
-        return [graph];
+    if (ts.isExpression(node2)) {
+      const nodeInfo = yield* extractNodeInfo(node2);
+      if (nodeInfo.layerTypes) {
+        yield* addNode2(node2, nodeInfo);
+        continue;
       }
-      return [];
     }
+    return yield* fail(new UnableToProduceLayerGraphError("Unable to produce layer graph for node", node2));
   }
-}
-function escapeMermaid(text) {
-  return text.replace(/"/mg, "#quot;").replace(/\n/mg, " ").replace(/</mg, "#lt;").replace(/>/mg, "#gt;");
-}
-function processNodeMermaid(graph, ctx, ctxL) {
-  return gen(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
+  return endMutation2(mutableGraph);
+});
+var formatLayerGraph = fn("formatLayerGraph")(function* (layerGraph) {
+  const tsUtils = yield* service(TypeScriptUtils);
+  return toMermaid(layerGraph, {
+    edgeLabel: (edge) => JSON.stringify(edge),
+    nodeLabel: (graphNode) => {
+      const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
+      return sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+    }
+  });
+});
+var formatNestedLayerGraph = fn("formatNestedLayerGraph")(function* (layerGraph) {
+  const tsUtils = yield* service(TypeScriptUtils);
+  const typeChecker = yield* service(TypeCheckerApi);
+  const ts = yield* service(TypeScriptApi);
+  const mermaidSafe = (value) => value.replace(/\n/g, " ").replace(
+    /\s+/g,
+    " "
+  ).substring(0, 50).replace(/"/g, "#quot;").replace(/</mg, "#lt;").replace(/>/mg, "#gt;").trim();
+  const typeNameCache = /* @__PURE__ */ new Map();
+  const typeName = (type) => {
+    if (typeNameCache.has(type)) return typeNameCache.get(type);
+    const name = typeChecker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
+    typeNameCache.set(type, name);
+    return name;
+  };
+  let result = [];
+  for (const [graphNodeIndex, graphNode] of entries(nodes(layerGraph))) {
     let subgraphDefs = [];
-    if (!ctx.seenIds.has(graph.id)) {
-      const subgraphsIn = [];
-      for (const serviceId of graph.rin) {
-        const type = ctxL.services.get(serviceId);
-        const typeString = typeChecker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
-        subgraphsIn.push("subgraph " + graph.id + "_rin_" + serviceId + ' ["`' + escapeMermaid(typeString) + '`"]');
-        subgraphsIn.push("end");
-      }
-      const subgraphsOut = [];
-      for (const serviceId of graph.rout) {
-        const type = ctxL.services.get(serviceId);
-        const typeString = typeChecker.typeToString(type, void 0, ts.TypeFormatFlags.NoTruncation);
-        subgraphsOut.push("subgraph " + graph.id + "_rout_" + serviceId + ' ["`' + escapeMermaid(typeString) + '`"]');
-        subgraphsOut.push("end");
-      }
-      const sourceFile = graph.node.getSourceFile();
-      const nodePosition = graph.node.getStart(sourceFile, false);
-      const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
-      if (subgraphsIn.length > 0) {
-        subgraphDefs = [
-          ...subgraphDefs,
-          "subgraph " + graph.id + "_rin [Requires]",
-          ...subgraphsIn,
-          "end",
-          "style " + graph.id + "_rin stroke:none"
-        ];
+    for (const kind of ["requires", "provides"]) {
+      const typesMermaidNodes = [];
+      for (let i = 0; i < graphNode[kind].length; i++) {
+        typesMermaidNodes.push(`${graphNodeIndex}_${kind}_${i}["${mermaidSafe(typeName(graphNode[kind][i]))}"]`);
       }
-      if (subgraphsOut.length > 0) {
+      if (typesMermaidNodes.length > 0) {
         subgraphDefs = [
           ...subgraphDefs,
-          "subgraph " + graph.id + "_rout [Provides]",
-          ...subgraphsOut,
-          "end",
-          "style " + graph.id + "_rout stroke:none"
+          `subgraph ${graphNodeIndex}_${kind} [${kind === "provides" ? "Provides" : "Requires"}]`,
+          ...typesMermaidNodes.map((_) => `  ${_}`),
+          `end`,
+          `style ${graphNodeIndex}_${kind} stroke:none`
         ];
       }
-      const nodeText = graph.node.getText().trim().replace(/\n/g, " ").substr(0, 50);
-      subgraphDefs = [
-        "subgraph " + graph.id + ' ["`' + escapeMermaid(nodeText) + " _at ln " + (line + 1) + " col " + character + '_`"]',
-        ...subgraphDefs,
-        "end",
-        "style " + graph.id + " fill:transparent"
-      ];
-      ctx.seenIds.add(graph.id);
-    }
-    switch (graph._tag) {
-      case "GraphNodeLeaf": {
-        return subgraphDefs;
-      }
-      case "GraphNodeCompoundTransform": {
-        const childs = flatten(yield* all(...graph.args.map((_) => processNodeMermaid(_, ctx, ctxL))));
-        let currentEdges = [];
-        const connectedNodes = /* @__PURE__ */ new Set();
-        for (const requiredServiceKey of graph.rin) {
-          for (const childNode of graph.args.filter((childNode2) => childNode2.rin.indexOf(requiredServiceKey) > -1)) {
-            currentEdges = [
-              ...currentEdges,
-              graph.id + "_rin_" + requiredServiceKey + " -.-> " + childNode.id + "_rin_" + requiredServiceKey
-            ];
-            connectedNodes.add(childNode.id);
-          }
+    }
+    subgraphDefs = [
+      `subgraph ${graphNodeIndex}_wrap[" "]`,
+      ...subgraphDefs.map((_) => `  ${_}`),
+      `end`,
+      `style ${graphNodeIndex}_wrap fill:transparent`,
+      `style ${graphNodeIndex}_wrap stroke:none`
+    ];
+    const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
+    const nodePosition = graphNode.node.getStart(sourceFile, false);
+    const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
+    const nodeText = sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+    result = [
+      ...result,
+      `subgraph ${graphNodeIndex} ["\`${mermaidSafe(nodeText)}<br/>_at ln ${line + 1} col ${character}_\`"]`,
+      ...subgraphDefs.map((_) => `  ${_}`),
+      `end`,
+      `style ${graphNodeIndex} fill:transparent`
+    ];
+  }
+  for (const edgeInfo of values2(edges(layerGraph))) {
+    const sourceData = layerGraph.nodes.get(edgeInfo.source);
+    const targetData = layerGraph.nodes.get(edgeInfo.target);
+    let connected = false;
+    for (const kind of ["requires", "provides"]) {
+      for (let i = 0; i < sourceData[kind].length; i++) {
+        const targetIdx = targetData[kind].indexOf(sourceData[kind][i]);
+        if (targetIdx > -1) {
+          result.push(`${edgeInfo.source}_${kind}_${i} -.-> ${edgeInfo.target}_${kind}_${targetIdx}`);
+          connected = true;
         }
-        for (const providedServiceKey of graph.rout) {
-          for (const childNode of graph.args.filter((childNode2) => childNode2.rout.indexOf(providedServiceKey) > -1)) {
-            currentEdges = [
-              ...currentEdges,
-              graph.id + "_rout_" + providedServiceKey + " -.-> " + childNode.id + "_rout_" + providedServiceKey
-            ];
-            connectedNodes.add(childNode.id);
+      }
+    }
+    if (!connected) {
+      result.push(`${edgeInfo.source} -.-x ${edgeInfo.target}`);
+    }
+  }
+  return [
+    `flowchart TB`,
+    ...result.map((_) => `  ${_}`)
+  ].join("\n");
+});
+var extractOutlineGraph = fn("extractOutlineGraph")(function* (layerGraph) {
+  const typeChecker = yield* service(TypeCheckerApi);
+  const mutableGraph = beginMutation3(directed());
+  const providers = /* @__PURE__ */ new WeakMap();
+  const knownSymbols = /* @__PURE__ */ new WeakSet();
+  const leafNodes = values2(externals(layerGraph, { direction: "outgoing" }));
+  const dedupedLeafNodes = [];
+  for (const leafNode of leafNodes) {
+    const symbol3 = typeChecker.getSymbolAtLocation(leafNode.node);
+    if (!symbol3) {
+      dedupedLeafNodes.push(leafNode);
+    } else if (symbol3 && !knownSymbols.has(symbol3)) {
+      dedupedLeafNodes.push(leafNode);
+      knownSymbols.add(symbol3);
+    }
+  }
+  for (const leafNode of dedupedLeafNodes) {
+    const nodeIndex = addNode(mutableGraph, {
+      node: leafNode.node,
+      requires: leafNode.requires,
+      provides: leafNode.provides
+    });
+    for (const providedType of leafNode.provides) {
+      if (leafNode.requires.indexOf(providedType) > -1) continue;
+      const previousProviders = providers.get(providedType) || [];
+      providers.set(providedType, [...previousProviders, nodeIndex]);
+    }
+  }
+  for (const [nodeIndex, nodeInfo] of entries(nodes(mutableGraph))) {
+    for (const requiredType of nodeInfo.requires) {
+      for (const providerNodeIndex of providers.get(requiredType) || []) {
+        addEdge(mutableGraph, nodeIndex, providerNodeIndex, {});
+      }
+    }
+  }
+  return endMutation2(mutableGraph);
+});
+var formatLayerOutlineGraph = fn("formatLayerOutlineGraph")(
+  function* (layerOutlineGraph) {
+    const tsUtils = yield* service(TypeScriptUtils);
+    return toMermaid(layerOutlineGraph, {
+      edgeLabel: () => "",
+      nodeLabel: (graphNode) => {
+        const sourceFile = tsUtils.getSourceFileOfNode(graphNode.node);
+        return sourceFile.text.substring(graphNode.node.pos, graphNode.node.end).trim();
+      }
+    });
+  }
+);
+var convertOutlineGraphToLayerMagic = fn("convertOutlineGraphToLayerMagic")(
+  function* (outlineGraph, targetOutput) {
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const ts = yield* service(TypeScriptApi);
+    const result = [];
+    const missingOutputTypes = new Set(typeCheckerUtils.unrollUnionMembers(targetOutput));
+    const currentRequiredTypes = /* @__PURE__ */ new Set();
+    const reversedGraph = mutate2(outlineGraph, reverse3);
+    const rootIndexes = fromIterable(indices(externals(reversedGraph, { direction: "incoming" })));
+    const allNodes = fromIterable(values2(dfsPostOrder(reversedGraph, { start: rootIndexes })));
+    for (const nodeInfo of allNodes) {
+      if (!ts.isExpression(nodeInfo.node)) continue;
+      const reallyProvidedTypes = nodeInfo.provides.filter((_) => nodeInfo.requires.indexOf(_) === -1);
+      const shouldMerge = reallyProvidedTypes.some((_) => missingOutputTypes.has(_));
+      if (shouldMerge) {
+        reallyProvidedTypes.forEach((_) => missingOutputTypes.delete(_));
+      }
+      nodeInfo.provides.forEach((_) => currentRequiredTypes.delete(_));
+      nodeInfo.requires.forEach((_) => currentRequiredTypes.add(_));
+      result.push({
+        merges: shouldMerge,
+        provides: true,
+        layerExpression: nodeInfo.node
+      });
+    }
+    return {
+      layerMagicNodes: result,
+      missingOutputTypes
+    };
+  }
+);
+var walkLeavesMatching = (graph, predicate, config = {}) => {
+  const start = config.start ?? [];
+  const direction = config.direction ?? "outgoing";
+  return new Walker((f) => ({
+    [Symbol.iterator]: () => {
+      let queue = [...start];
+      const discovered = /* @__PURE__ */ new Set();
+      const nextMapped = () => {
+        while (queue.length > 0) {
+          const current = queue.shift();
+          if (discovered.has(current)) continue;
+          discovered.add(current);
+          const neighbors = neighborsDirected(graph, current, direction);
+          const neighborsMatching = [];
+          for (const neighbor of neighbors) {
+            const neighborNode = getNode(graph, neighbor);
+            if (isSome2(neighborNode) && predicate(neighborNode.value)) {
+              neighborsMatching.push(neighbor);
+            }
           }
-        }
-        for (const childNode of graph.args) {
-          if (!connectedNodes.has(childNode.id)) {
-            currentEdges = [...currentEdges, graph.id + " -.-x " + childNode.id];
+          if (neighborsMatching.length > 0) {
+            queue = [...queue, ...neighborsMatching];
+          } else {
+            const nodeData = getNode(graph, current);
+            if (isSome2(nodeData) && predicate(nodeData.value)) {
+              return { done: false, value: f(current, nodeData.value) };
+            }
           }
         }
-        return [...subgraphDefs, ...childs, ...currentEdges];
+        return { done: true, value: void 0 };
+      };
+      return { next: nextMapped };
+    }
+  }));
+};
+var extractProvidersAndRequirers = fn("extractProvidersAndRequirers")(
+  function* (layerGraph) {
+    const typeCheckerUtils = yield* service(TypeCheckerUtils);
+    const rootWalker = externals(layerGraph, { direction: "outgoing" });
+    const rootNodes = fromIterable(values2(rootWalker));
+    const rootNodeIndexes = fromIterable(indices(rootWalker));
+    const result = [];
+    const walkTypes = (rootTypes, kind) => {
+      const sortedTypes = pipe(fromIterable(rootTypes), sort(typeCheckerUtils.deterministicTypeOrder));
+      for (const layerType of sortedTypes) {
+        const tsNodes = [];
+        for (const layerNode of values2(
+          walkLeavesMatching(
+            layerGraph,
+            (_) => (kind === "provided" ? _.provides : _.requires).indexOf(layerType) > -1,
+            { start: rootNodeIndexes }
+          )
+        )) {
+          tsNodes.push(layerNode.node);
+        }
+        result.push({
+          kind,
+          type: layerType,
+          nodes: tsNodes
+        });
+      }
+    };
+    walkTypes(new Set(rootNodes.flatMap((_) => _.provides)), "provided");
+    walkTypes(new Set(rootNodes.flatMap((_) => _.requires)), "required");
+    return result;
+  }
+);
+var formatLayerProvidersAndRequirersInfo = fn("formatLayerProvidersAndRequirersInfo")(
+  function* (info) {
+    const typeChecker = yield* service(TypeCheckerApi);
+    const ts = yield* service(TypeScriptApi);
+    const tsUtils = yield* service(TypeScriptUtils);
+    if (info.length === 0) return "";
+    const textualExplanation = [];
+    const appendInfo = (infoNode) => {
+      const typeString = typeChecker.typeToString(
+        infoNode.type,
+        void 0,
+        ts.TypeFormatFlags.NoTruncation
+      );
+      const positions = infoNode.nodes.map((_) => {
+        const sourceFile = tsUtils.getSourceFileOfNode(_);
+        const nodePosition = ts.getTokenPosOfNode(_, sourceFile);
+        const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
+        const nodeText = sourceFile.text.substring(_.pos, _.end).trim().replace(/\n/g, " ").substr(0, 50);
+        return `ln ${line + 1} col ${character} by \`${nodeText}\``;
+      });
+      textualExplanation.push(`- ${typeString} ${infoNode.kind} at ${positions.join(", ")}`);
+    };
+    const providedItems = info.filter((_) => _.kind === "provided");
+    const requiredItems = info.filter((_) => _.kind === "required");
+    if (providedItems.length > 0) {
+      for (const item of providedItems) {
+        appendInfo(item);
       }
+      if (textualExplanation.length > 0 && requiredItems.length > 0) textualExplanation.push("");
     }
-  });
-}
+    if (requiredItems.length > 0) {
+      for (const item of requiredItems) {
+        appendInfo(item);
+      }
+    }
+    return "/**\n" + textualExplanation.map((l) => " * " + l).join("\n") + "\n */";
+  }
+);
+
+// src/quickinfo/layerInfo.ts
 function generateMarmaidUri(code) {
   return gen(function* () {
     const state = JSON.stringify({ code });
@@ -11695,61 +14119,32 @@ function getAdjustedNode(sourceFile, position) {
     return { node, layerNode };
   });
 }
-function parseLayerGraph(sourceFile, layerNode) {
+function parseLayerGraph(layerNode) {
   return gen(function* () {
-    const ts = yield* service(TypeScriptApi);
-    const typeChecker = yield* service(TypeCheckerApi);
-    let lastId = 0;
-    const graphCtx = {
-      services: /* @__PURE__ */ new Map(),
-      serviceTypeToString: /* @__PURE__ */ new Map(),
-      nextId: () => "id" + lastId++
-    };
-    const rootNode = yield* processLayerGraphNode(graphCtx, layerNode, void 0);
-    const ctx = {
-      seenIds: /* @__PURE__ */ new Set()
-    };
-    const mermaidLines = yield* processNodeMermaid(rootNode, ctx, graphCtx);
-    const mermaidCode = "flowchart TB\n" + mermaidLines.join("\n");
-    const textualExplanation = [];
-    const appendInfo = (providesNode, type, kindText) => {
-      const typeString = typeChecker.typeToString(
-        type,
-        void 0,
-        ts.TypeFormatFlags.NoTruncation
-      );
-      const positions = providesNode.map((_) => {
-        const nodePosition = _.node.getStart(sourceFile, false);
-        const { character, line } = ts.getLineAndCharacterOfPosition(sourceFile, nodePosition);
-        const nodeText = _.node.getText().trim().replace(/\n/g, " ").substr(0, 50);
-        return "ln " + (line + 1) + " col " + character + " by `" + nodeText + "`";
-      });
-      textualExplanation.push("- " + typeString + " " + kindText + " at " + positions.join(", "));
-    };
-    for (const providesKey of rootNode.rout) {
-      const providesNode = findInnermostGraphEdge(rootNode, "rout", providesKey);
-      appendInfo(providesNode, graphCtx.services.get(providesKey), "provided");
-    }
-    if (textualExplanation.length > 0) textualExplanation.push("");
-    for (const requiresKey of rootNode.rin) {
-      const requiresNode = findInnermostGraphEdge(rootNode, "rin", requiresKey);
-      appendInfo(requiresNode, graphCtx.services.get(requiresKey), "required");
-    }
-    return { mermaidCode, textualExplanation };
+    const layerGraph = yield* extractLayerGraph(layerNode, {
+      arrayLiteralAsMerge: false,
+      explodeOnlyLayerCalls: false
+    });
+    const nestedGraphMermaid = yield* formatNestedLayerGraph(layerGraph);
+    const outlineGraph = yield* extractOutlineGraph(layerGraph);
+    const outlineGraphMermaid = yield* formatLayerOutlineGraph(outlineGraph);
+    const providersAndRequirers = yield* extractProvidersAndRequirers(layerGraph);
+    const providersAndRequirersTextualExplanation = yield* formatLayerProvidersAndRequirersInfo(
+      providersAndRequirers
+    );
+    return { nestedGraphMermaid, outlineGraphMermaid, providersAndRequirersTextualExplanation };
   });
 }
 function effectApiGetLayerGraph(sourceFile, line, character) {
-  return pipe(
-    gen(function* () {
-      const ts = yield* service(TypeScriptApi);
-      const position = ts.getPositionOfLineAndCharacter(sourceFile, line, character);
-      const maybeNodes = yield* getAdjustedNode(sourceFile, position);
-      if (!maybeNodes) return yield* fail(new UnableToProduceLayerGraphError("No node found"));
-      const { layerNode, node } = maybeNodes;
-      const { mermaidCode } = yield* parseLayerGraph(sourceFile, layerNode);
-      return { start: node.pos, end: node.end, mermaidCode };
-    })
-  );
+  return gen(function* () {
+    const ts = yield* service(TypeScriptApi);
+    const position = ts.getPositionOfLineAndCharacter(sourceFile, line, character);
+    const maybeNodes = yield* getAdjustedNode(sourceFile, position);
+    if (!maybeNodes) return yield* fail(new UnableToProduceLayerGraphError("No node found"));
+    const { layerNode, node } = maybeNodes;
+    const { nestedGraphMermaid } = yield* parseLayerGraph(layerNode);
+    return { start: node.pos, end: node.end, mermaidCode: nestedGraphMermaid };
+  });
 }
 function layerInfo(sourceFile, position, quickInfo2) {
   return pipe(
@@ -11760,35 +14155,36 @@ function layerInfo(sourceFile, position, quickInfo2) {
       if (!maybeNodes) return quickInfo2;
       const { layerNode, node } = maybeNodes;
       const layerInfoDisplayParts = yield* pipe(
-        parseLayerGraph(sourceFile, layerNode),
+        parseLayerGraph(layerNode),
         flatMap2(
-          ({ mermaidCode, textualExplanation }) => gen(function* () {
+          ({ nestedGraphMermaid, outlineGraphMermaid, providersAndRequirersTextualExplanation }) => gen(function* () {
             const linkParts = [];
             if (!options.noExternal) {
-              const mermaidUri = yield* generateMarmaidUri(mermaidCode);
+              const mermaidUri = yield* generateMarmaidUri(nestedGraphMermaid);
+              const outlineMermaidUri = yield* generateMarmaidUri(outlineGraphMermaid);
               linkParts.push({ kind: "space", text: "\n" });
               linkParts.push({ kind: "link", text: "{@link " });
               linkParts.push({ kind: "linkText", text: mermaidUri + " Show full Layer graph" });
               linkParts.push({ kind: "link", text: "}" });
+              linkParts.push({ kind: "text", text: " - " });
+              linkParts.push({ kind: "link", text: "{@link " });
+              linkParts.push({ kind: "linkText", text: outlineMermaidUri + " Show Layer outline" });
+              linkParts.push({ kind: "link", text: "}" });
               linkParts.push({ kind: "space", text: "\n" });
             }
-            if (textualExplanation.length === 0) return linkParts;
+            if (providersAndRequirersTextualExplanation.length === 0) return linkParts;
             return [
               {
                 kind: "text",
-                text: "```\n/**\n" + textualExplanation.map((l) => " * " + l).join("\n") + "\n */\n```\n"
+                text: "```\n" + providersAndRequirersTextualExplanation + "\n```\n"
               },
               ...linkParts
             ];
           })
         ),
-        orElse2(
-          (e) => succeed([{
-            kind: "text",
-            text: "```\n/** layer graph not created: " + e.message + " */\n```\n"
-          }])
-        )
+        orElse2(() => succeed([]))
       );
+      if (layerInfoDisplayParts.length === 0) return quickInfo2;
       if (!quickInfo2) {
         const start = ts.getTokenPosOfNode(node, sourceFile);
         const end = node.end;
@@ -12304,71 +14700,6 @@ var functionToArrow = createRefactor({
 });
 
 // src/refactors/layerMagic.ts
-function sortDependencies(nodes) {
-  const result = [];
-  const visited = /* @__PURE__ */ new Set();
-  const visiting = /* @__PURE__ */ new Set();
-  const cycles = [];
-  const providesMap = /* @__PURE__ */ new Map();
-  Object.entries(nodes).forEach(([nodeId, node]) => {
-    node.provides.forEach((service2) => {
-      if (!providesMap.has(service2)) {
-        providesMap.set(service2, []);
-      }
-      providesMap.get(service2).push(nodeId);
-    });
-  });
-  providesMap.forEach((nodeIds) => {
-    nodeIds.sort((a, b) => {
-      const nodeA = nodes[a];
-      const nodeB = nodes[b];
-      return nodeA.requires.length - nodeB.requires.length;
-    });
-  });
-  const visit = (nodeId, path) => {
-    if (visited.has(nodeId)) {
-      return;
-    }
-    if (visiting.has(nodeId)) {
-      const cycleStart = path.indexOf(nodeId);
-      const cycle = path.slice(cycleStart).concat([nodeId]);
-      const cycleServices = cycle.map((id) => {
-        const node2 = nodes[id];
-        return `${node2.provides.join(", ")} (requires: ${node2.requires.join(", ")})`;
-      });
-      cycles.push(cycleServices);
-      return;
-    }
-    visiting.add(nodeId);
-    const currentPath = [...path, nodeId];
-    const dependencies = /* @__PURE__ */ new Set();
-    const node = nodes[nodeId];
-    node.requires.forEach((requiredService) => {
-      const providers = providesMap.get(requiredService) || [];
-      providers.forEach((providerId) => {
-        if (providerId !== nodeId) {
-          dependencies.add(providerId);
-        }
-      });
-    });
-    dependencies.forEach((depId) => {
-      visit(depId, currentPath);
-    });
-    visiting.delete(nodeId);
-    visited.add(nodeId);
-    result.push(node);
-  };
-  Object.keys(nodes).forEach((nodeId) => {
-    if (!visited.has(nodeId)) {
-      visit(nodeId, []);
-    }
-  });
-  return {
-    sorted: result,
-    cycles,
-    hasCycles: cycles.length > 0
-  };
-}
 var layerMagic = createRefactor({
   name: "layerMagic",
   description: "Layer Magic",
@@ -12383,56 +14714,6 @@ var layerMagic = createRefactor({
       "effect",
       "Layer"
     ) || "Layer";
-    const extractArrayLiteral = (node) => {
-      if (ts.isArrayLiteralExpression(node)) {
-        return pipe(
-          all(...node.elements.map((element) => extractLayers(element, false))),
-          map5(flatten)
-        );
-      }
-      return TypeParserIssue.issue;
-    };
-    const extractLayerExpression = (node) => {
-      if (ts.isExpression(node)) {
-        return pipe(
-          typeParser.layerType(typeChecker.getTypeAtLocation(node), node),
-          map5((_) => [{ node, ..._ }])
-        );
-      }
-      return TypeParserIssue.issue;
-    };
-    const extractLayerApi = (node) => {
-      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && ts.idText(node.expression.expression) === layerIdentifier && ts.isIdentifier(node.expression.name) && ["provide", "provideMerge", "merge", "mergeAll"].map((_) => _.toLowerCase()).indexOf(
-        ts.idText(node.expression.name).toLowerCase()
-      ) > -1) {
-        return pipe(
-          all(...node.arguments.map((element) => extractLayers(element, false))),
-          map5(flatten)
-        );
-      }
-      return TypeParserIssue.issue;
-    };
-    const extractPipeSequencing = (node) => {
-      return pipe(
-        typeParser.pipeCall(node),
-        flatMap2((_) => {
-          return all(...[_.subject, ..._.args].map((element) => extractLayers(element, true)));
-        }),
-        map5(flatten)
-      );
-    };
-    const extractLayers = cachedBy(
-      fn("layerMagic.apply.extractLayerArray")(function* (node, _inPipeContext) {
-        return yield* pipe(
-          extractArrayLiteral(node),
-          orElse2(() => extractLayerApi(node)),
-          _inPipeContext ? (x) => x : orElse2(() => extractPipeSequencing(node)),
-          orElse2(() => extractLayerExpression(node))
-        );
-      }),
-      "layerMagic.apply.extractLayerArray",
-      (node) => node
-    );
     const adjustedNode = (node) => {
       if (node.parent && (ts.isVariableDeclaration(node.parent) || ts.isPropertyDeclaration(node.parent)) && ts.isIdentifier(node) && node.parent.initializer && node.parent.name === node) {
         return node.parent.initializer;
@@ -12442,9 +14723,13 @@ var layerMagic = createRefactor({
     const computeAsAnyAsLayerRefactor = (node) => {
       const atLocation = adjustedNode(node);
       return pipe(
-        extractLayers(atLocation, false),
+        extractLayerGraph(atLocation, {
+          arrayLiteralAsMerge: true,
+          explodeOnlyLayerCalls: true
+        }),
+        flatMap2(extractOutlineGraph),
         flatMap2(
-          (extractedLayer) => extractedLayer.length <= 1 ? TypeParserIssue.issue : succeed(extractedLayer)
+          (extractedLayer) => nodeCount(extractedLayer) <= 1 ? TypeParserIssue.issue : succeed(extractedLayer)
         ),
         map5((extractedLayers) => ({
           kind: "refactor.rewrite.effect.layerMagicPrepare",
@@ -12452,21 +14737,27 @@ var layerMagic = createRefactor({
           apply: pipe(
             gen(function* () {
               const changeTracker = yield* service(ChangeTracker);
-              const memory = /* @__PURE__ */ new Map();
-              for (const layer of extractedLayers) {
-                yield* typeCheckerUtils.appendToUniqueTypesMap(
-                  memory,
-                  layer.ROut,
-                  (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
-                );
+              const layerOutputTypes = /* @__PURE__ */ new Set();
+              for (const layer of values2(nodes(extractedLayers))) {
+                layer.provides.forEach((_) => layerOutputTypes.add(_));
               }
+              const layerNodes = pipe(
+                values2(nodes(extractedLayers)),
+                fromIterable,
+                map4((_) => _.node),
+                filter(ts.isExpression),
+                sort(mapInput(
+                  number2,
+                  (_) => _.pos
+                ))
+              );
               const previouslyProvided = yield* pipe(
                 typeParser.layerType(typeChecker.getTypeAtLocation(atLocation), atLocation),
                 map5((_) => _.ROut),
                 option
               );
               const [existingBefore, newlyIntroduced] = pipe(
-                fromIterable(memory.values()),
+                fromIterable(layerOutputTypes),
                 sort(typeCheckerUtils.deterministicTypeOrder),
                 partition(
                   (_) => isNone2(previouslyProvided) || typeChecker.isTypeAssignableTo(_, previouslyProvided.value)
@@ -12491,7 +14782,7 @@ var layerMagic = createRefactor({
               );
               const newDeclaration = ts.factory.createAsExpression(
                 ts.factory.createAsExpression(
-                  ts.factory.createArrayLiteralExpression(extractedLayers.map((_) => _.node)),
+                  ts.factory.createArrayLiteralExpression(layerNodes),
                   ts.factory.createTypeReferenceNode("any")
                 ),
                 ts.factory.createTypeReferenceNode(
@@ -12513,8 +14804,9 @@ var layerMagic = createRefactor({
       if (ts.isAsExpression(node) && ts.isTypeReferenceNode(node.type)) {
         const expression = node.expression;
         if (ts.isAsExpression(expression) && expression.type.kind === ts.SyntaxKind.AnyKeyword) {
+          const type = typeChecker.getTypeAtLocation(node.type);
           return pipe(
-            typeParser.layerType(typeChecker.getTypeAtLocation(node.type), node.type),
+            typeParser.layerType(type, node.type),
             map5((_) => ({ node, ..._, castedStructure: expression.expression }))
           );
         }
@@ -12527,80 +14819,49 @@ var layerMagic = createRefactor({
         parseAsAnyAsLayer(atLocation),
         flatMap2(
           (_targetLayer) => pipe(
-            extractArrayLiteral(_targetLayer.castedStructure),
-            orElse2(() => extractLayers(_targetLayer.castedStructure, false)),
+            extractLayerGraph(_targetLayer.castedStructure, {
+              arrayLiteralAsMerge: true,
+              explodeOnlyLayerCalls: true
+            }),
+            flatMap2(extractOutlineGraph),
             flatMap2(
-              (extractedLayer) => extractedLayer.length <= 1 ? TypeParserIssue.issue : succeed(extractedLayer)
+              (extractedLayer) => nodeCount(extractedLayer) <= 1 ? TypeParserIssue.issue : succeed(extractedLayer)
             ),
             map5((extractedLayers) => ({
               kind: "refactor.rewrite.effect.layerMagicBuild",
               description: "Compose layers automatically with target output services",
               apply: gen(function* () {
                 const changeTracker = yield* service(ChangeTracker);
-                const memory = /* @__PURE__ */ new Map();
-                const { allIndexes: outputIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-                  memory,
-                  _targetLayer.ROut,
-                  (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
+                const { layerMagicNodes, missingOutputTypes } = yield* pipe(
+                  convertOutlineGraphToLayerMagic(
+                    extractedLayers,
+                    _targetLayer.ROut
+                  ),
+                  provideService(TypeCheckerApi, typeChecker),
+                  provideService(TypeCheckerUtils, typeCheckerUtils),
+                  provideService(TypeScriptApi, ts)
                 );
-                const nodes = {};
-                for (let i = 0; i < extractedLayers.length; i++) {
-                  const layer = extractedLayers[i];
-                  const { allIndexes: providedIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-                    memory,
-                    layer.ROut,
-                    (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
-                  );
-                  const { allIndexes: requiredIndexes } = yield* typeCheckerUtils.appendToUniqueTypesMap(
-                    memory,
-                    layer.RIn,
-                    (_) => succeed((_.flags & ts.TypeFlags.Never) !== 0)
-                  );
-                  nodes[`node_${i}`] = {
-                    provides: providedIndexes.filter((_) => requiredIndexes.indexOf(_) === -1),
-                    // only provide indexes that are not required
-                    requires: requiredIndexes,
-                    node: layer.node
-                  };
-                }
-                const sortResult = sortDependencies(nodes);
-                const sortedNodes = sortResult.sorted.reverse();
-                const missingOutput = new Set(outputIndexes);
-                const missingInternal = /* @__PURE__ */ new Set();
-                const outputEntry = [];
-                for (let i = 0; i < sortedNodes.length; i++) {
-                  const graphNode = sortedNodes[i];
-                  const mergeOutput = graphNode.provides.filter((_) => missingOutput.has(_));
-                  const provideInternal = graphNode.provides.filter((_) => missingInternal.has(_));
-                  graphNode.requires.forEach((_) => missingInternal.add(_));
-                  mergeOutput.forEach((_) => missingOutput.delete(_));
-                  outputEntry.push({
-                    merges: mergeOutput.length > 0,
-                    provides: provideInternal.length > 0,
-                    node: graphNode.node
-                  });
-                }
                 const newDeclaration = ts.factory.createCallExpression(
                   ts.factory.createPropertyAccessExpression(
-                    outputEntry[0].node,
+                    layerMagicNodes[0].layerExpression,
                     "pipe"
                   ),
                   [],
-                  outputEntry.slice(1).map(
+                  layerMagicNodes.slice(1).map(
                     (_) => ts.factory.createCallExpression(
                       ts.factory.createPropertyAccessExpression(
                         ts.factory.createIdentifier(layerIdentifier),
                         _.merges && _.provides ? "provideMerge" : _.merges ? "merge" : "provide"
                       ),
                       [],
-                      [_.node]
+                      [_.layerExpression]
                     )
                   )
                 );
-                const newDeclarationWithComment = missingOutput.size > 0 ? ts.addSyntheticTrailingComment(
+                const newDeclarationWithComment = missingOutputTypes.size > 0 ? ts.addSyntheticTrailingComment(
                   newDeclaration,
                   ts.SyntaxKind.MultiLineCommentTrivia,
-                  " Unable to find " + fromIterable(missingOutput).map((key) => memory.get(key)).map(
+                  " Unable to find " + fromIterable(missingOutputTypes.values()).map(
                     (_) => typeChecker.typeToString(_, void 0, ts.TypeFormatFlags.NoTruncation)
                   ).join(", ") + " in the provided layers. ",
                   false