@effect/language-service 0.28.1 → 0.28.3

package/index.js

@@ -1,11 +1,6 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __export = (target, all3) => {
-  for (var name in all3)
-    __defProp(target, name, { get: all3[name], enumerable: true });
-};
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Function.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Function.js
 var isFunction = (input) => typeof input === "function";
 var dual = function(arity, body) {
   if (typeof arity === "function") {
@@ -101,7 +96,7 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
   }
 }
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Equivalence.js
+// node_modules/.pnpm/effect@3.17.1/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) {
@@ -116,12 +111,8 @@ var array = (item) => make((self, that) => {
   return true;
 });
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/version.js
-var moduleVersion = "3.16.12";
-var getCurrentVersion = () => moduleVersion;
-
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/GlobalValue.js
-var globalStoreId = `effect/GlobalValue/globalStoreId/${/* @__PURE__ */ getCurrentVersion()}`;
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/GlobalValue.js
+var globalStoreId = `effect/GlobalValue`;
 var globalStore;
 var globalValue = (id, compute) => {
   if (!globalStore) {
@@ -134,156 +125,20 @@ var globalValue = (id, compute) => {
   return globalStore.get(id);
 };
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Predicate.js
-var Predicate_exports = {};
-__export(Predicate_exports, {
-  all: () => all,
-  and: () => and,
-  compose: () => compose,
-  eqv: () => eqv,
-  every: () => every,
-  hasProperty: () => hasProperty,
-  implies: () => implies,
-  isBigInt: () => isBigInt,
-  isBoolean: () => isBoolean,
-  isDate: () => isDate,
-  isError: () => isError,
-  isFunction: () => isFunction2,
-  isIterable: () => isIterable,
-  isMap: () => isMap,
-  isNever: () => isNever,
-  isNotNull: () => isNotNull,
-  isNotNullable: () => isNotNullable,
-  isNotUndefined: () => isNotUndefined,
-  isNull: () => isNull,
-  isNullable: () => isNullable,
-  isNumber: () => isNumber,
-  isObject: () => isObject,
-  isPromise: () => isPromise,
-  isPromiseLike: () => isPromiseLike,
-  isPropertyKey: () => isPropertyKey,
-  isReadonlyRecord: () => isReadonlyRecord,
-  isRecord: () => isRecord,
-  isRecordOrArray: () => isRecordOrArray,
-  isRegExp: () => isRegExp,
-  isSet: () => isSet,
-  isString: () => isString,
-  isSymbol: () => isSymbol,
-  isTagged: () => isTagged,
-  isTruthy: () => isTruthy,
-  isTupleOf: () => isTupleOf,
-  isTupleOfAtLeast: () => isTupleOfAtLeast,
-  isUint8Array: () => isUint8Array,
-  isUndefined: () => isUndefined,
-  isUnknown: () => isUnknown,
-  mapInput: () => mapInput,
-  nand: () => nand,
-  nor: () => nor,
-  not: () => not,
-  or: () => or,
-  product: () => product,
-  productMany: () => productMany,
-  some: () => some,
-  struct: () => struct,
-  tuple: () => tuple,
-  xor: () => xor
-});
-var mapInput = /* @__PURE__ */ dual(2, (self, f) => (b) => self(f(b)));
-var isTupleOf = /* @__PURE__ */ dual(2, (self, n) => self.length === n);
-var isTupleOfAtLeast = /* @__PURE__ */ dual(2, (self, n) => self.length >= n);
-var isTruthy = (input) => !!input;
-var isSet = (input) => input instanceof Set;
-var isMap = (input) => input instanceof Map;
+// node_modules/.pnpm/effect@3.17.1/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";
-var isBigInt = (input) => typeof input === "bigint";
-var isSymbol = (input) => typeof input === "symbol";
-var isPropertyKey = (u) => isString(u) || isNumber(u) || isSymbol(u);
 var isFunction2 = isFunction;
-var isUndefined = (input) => input === void 0;
-var isNotUndefined = (input) => input !== void 0;
-var isNull = (input) => input === null;
-var isNotNull = (input) => input !== null;
-var isNever = (_) => false;
-var isUnknown = (_) => true;
 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 isNullable = (input) => input === null || input === void 0;
-var isNotNullable = (input) => input !== null && input !== void 0;
-var isError = (input) => input instanceof Error;
-var isUint8Array = (input) => input instanceof Uint8Array;
-var isDate = (input) => input instanceof Date;
-var isIterable = (input) => hasProperty(input, Symbol.iterator);
 var isRecord = (input) => isRecordOrArray(input) && !Array.isArray(input);
-var isReadonlyRecord = isRecord;
-var isPromise = (input) => hasProperty(input, "then") && "catch" in input && isFunction2(input.then) && isFunction2(input.catch);
-var isPromiseLike = (input) => hasProperty(input, "then") && isFunction2(input.then);
-var isRegExp = (input) => input instanceof RegExp;
-var compose = /* @__PURE__ */ dual(2, (ab, bc) => (a) => ab(a) && bc(a));
-var product = (self, that) => ([a, b]) => self(a) && that(b);
-var all = (collection) => {
-  return (as) => {
-    let collectionIndex = 0;
-    for (const p of collection) {
-      if (collectionIndex >= as.length) {
-        break;
-      }
-      if (p(as[collectionIndex]) === false) {
-        return false;
-      }
-      collectionIndex++;
-    }
-    return true;
-  };
-};
-var productMany = (self, collection) => {
-  const rest = all(collection);
-  return ([head2, ...tail]) => self(head2) === false ? false : rest(tail);
-};
-var tuple = (...elements) => all(elements);
-var struct = (fields) => {
-  const keys = Object.keys(fields);
-  return (a) => {
-    for (const key of keys) {
-      if (!fields[key](a[key])) {
-        return false;
-      }
-    }
-    return true;
-  };
-};
-var not = (self) => (a) => !self(a);
-var or = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) || that(a));
-var and = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) && that(a));
-var xor = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) !== that(a));
-var eqv = /* @__PURE__ */ dual(2, (self, that) => (a) => self(a) === that(a));
-var implies = /* @__PURE__ */ dual(2, (antecedent, consequent) => (a) => antecedent(a) ? consequent(a) : true);
-var nor = /* @__PURE__ */ dual(2, (self, that) => (a) => !(self(a) || that(a)));
-var nand = /* @__PURE__ */ dual(2, (self, that) => (a) => !(self(a) && that(a)));
-var every = (collection) => (a) => {
-  for (const p of collection) {
-    if (!p(a)) {
-      return false;
-    }
-  }
-  return true;
-};
-var some = (collection) => (a) => {
-  for (const p of collection) {
-    if (p(a)) {
-      return true;
-    }
-  }
-  return false;
-};
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/errors.js
+// node_modules/.pnpm/effect@3.17.1/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/effect@3.16.12/node_modules/effect/dist/esm/Utils.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Utils.js
 var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
 var GenKindImpl = class {
   value;
@@ -411,7 +266,7 @@ var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forc
 var genConstructor = function* () {
 }.constructor;
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Hash.js
+// node_modules/.pnpm/effect@3.17.1/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) => {
@@ -510,7 +365,7 @@ var cached = function() {
   return hash2;
 };
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Equal.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Equal.js
 var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
 function equals() {
   if (arguments.length === 1) {
@@ -564,7 +419,7 @@ function compareBoth(self, that) {
 var isEqual = (u) => hasProperty(u, symbol2);
 var equivalence = () => equals;
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Inspectable.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Inspectable.js
 var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
 var toJSON = (x) => {
   try {
@@ -616,7 +471,7 @@ var redact = (u) => {
   return u;
 };
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Pipeable.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Pipeable.js
 var pipeArguments = (self, args2) => {
   switch (args2.length) {
     case 0:
@@ -649,10 +504,14 @@ var pipeArguments = (self, args2) => {
   }
 };
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/opCodes/effect.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/opCodes/effect.js
 var OP_COMMIT = "Commit";
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/effectable.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/version.js
+var moduleVersion = "3.17.1";
+var getCurrentVersion = () => moduleVersion;
+
+// node_modules/.pnpm/effect@3.17.1/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");
@@ -739,7 +598,7 @@ var StructuralCommitPrototype = {
   ...StructuralPrototype
 };
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/option.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/option.js
 var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
 var CommonProto = {
   ...EffectPrototype,
@@ -791,13 +650,13 @@ var isOption = (input) => hasProperty(input, TypeId);
 var isNone = (fa) => fa._tag === "None";
 var isSome = (fa) => fa._tag === "Some";
 var none = /* @__PURE__ */ Object.create(NoneProto);
-var some2 = (value) => {
+var some = (value) => {
   const a = Object.create(SomeProto);
   a.value = value;
   return a;
 };
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/either.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/either.js
 var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
 var CommonProto2 = {
   ...EffectPrototype,
@@ -859,7 +718,7 @@ var right = (right3) => {
   return a;
 };
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Either.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Either.js
 var right2 = right;
 var left2 = left;
 var isLeft2 = isLeft;
@@ -867,13 +726,13 @@ 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.16.12/node_modules/effect/dist/esm/Order.js
+// node_modules/.pnpm/effect@3.17.1/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);
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Option.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/Option.js
 var none2 = () => none;
-var some3 = some2;
+var some2 = some;
 var isNone2 = isNone;
 var isSome2 = isSome;
 var match = /* @__PURE__ */ dual(2, (self, {
@@ -882,14 +741,14 @@ var match = /* @__PURE__ */ dual(2, (self, {
 }) => isNone2(self) ? onNone() : onSome(self.value));
 var getOrElse2 = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
 var orElse = /* @__PURE__ */ dual(2, (self, that) => isNone2(self) ? that() : self);
-var fromNullable = (nullableValue) => nullableValue == null ? none2() : some3(nullableValue);
+var fromNullable = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
 var getOrUndefined = /* @__PURE__ */ getOrElse2(constUndefined);
-var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some3(f(self.value)));
+var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/array.js
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/array.js
 var isNonEmptyArray = (self) => self.length > 0;
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/Array.js
+// node_modules/.pnpm/effect@3.17.1/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)));
@@ -900,7 +759,7 @@ var isNonEmptyReadonlyArray = isNonEmptyArray;
 var isOutOfBounds = (i, as) => i < 0 || i >= as.length;
 var get = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
-  return isOutOfBounds(i, self) ? none2() : some3(self[i]);
+  return isOutOfBounds(i, self) ? none2() : some2(self[i]);
 });
 var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
   const i = Math.floor(index);
@@ -957,7 +816,7 @@ var filter = /* @__PURE__ */ dual(2, (self, predicate) => {
   }
   return out;
 });
-var every2 = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
+var every = /* @__PURE__ */ dual(2, (self, refinement) => self.every(refinement));
 var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
   const input = fromIterable(self);
   if (isNonEmptyReadonlyArray(input)) {
@@ -1226,7 +1085,7 @@ function cachedBy(fa, type, lookupKey) {
 var option = (fa) => {
   const nano = Object.create(MatchProto);
   nano[args] = fa;
-  nano[contA] = (_) => succeed(some3(_));
+  nano[contA] = (_) => succeed(some2(_));
   nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : succeed(none2());
   return nano;
 };
@@ -1237,7 +1096,7 @@ var ignore = (fa) => {
   nano[contE] = (_) => _ instanceof NanoDefectException ? fail(_) : void_;
   return nano;
 };
-var all2 = fn("all")(
+var all = fn("all")(
   function* (...args2) {
     const results = [];
     for (const fa of args2) {
@@ -1483,7 +1342,7 @@ var findImportedModuleIdentifier = fn("AST.findImportedModuleIdentifier")(
       } else if (ts.isNamedImports(namedBindings)) {
         for (const importSpecifier of namedBindings.elements) {
           const importProperty = fromNullable(importSpecifier.propertyName).pipe(
-            orElse(() => some3(importSpecifier.name))
+            orElse(() => some2(importSpecifier.name))
           );
           if (yield* test(importSpecifier.name, statement.moduleSpecifier, importProperty)) {
             return importSpecifier.name;
@@ -1516,20 +1375,20 @@ var simplifyTypeNode = fn("AST.simplifyTypeNode")(function* (typeNode) {
   function collectCallable(typeNode2) {
     if (ts.isParenthesizedTypeNode(typeNode2)) return collectCallable(typeNode2.type);
     if (ts.isFunctionTypeNode(typeNode2)) {
-      return some3([
+      return some2([
         ts.factory.createCallSignature(typeNode2.typeParameters, typeNode2.parameters, typeNode2.type)
       ]);
     }
     if (ts.isTypeLiteralNode(typeNode2)) {
       const allCallSignatures = typeNode2.members.every(ts.isCallSignatureDeclaration);
       if (allCallSignatures) {
-        return some3(typeNode2.members);
+        return some2(typeNode2.members);
       }
     }
     if (ts.isIntersectionTypeNode(typeNode2)) {
       const members = typeNode2.types.map((node) => collectCallable(node));
       if (members.every(isSome2)) {
-        return some3(members.map((_) => isSome2(_) ? _.value : []).flat());
+        return some2(members.map((_) => isSome2(_) ? _.value : []).flat());
       }
     }
     return none2();
@@ -2445,7 +2304,7 @@ function make3(ts, typeChecker) {
     return invariantTypeArgument(propertyType);
   };
   const effectVarianceStruct = (type, atLocation) => map4(
-    all2(
+    all(
       varianceStructCovariantType(type, atLocation, "_A"),
       varianceStructCovariantType(type, atLocation, "_E"),
       varianceStructCovariantType(type, atLocation, "_R")
@@ -2453,7 +2312,7 @@ function make3(ts, typeChecker) {
     ([A, E, R]) => ({ A, E, R })
   );
   const layerVarianceStruct = (type, atLocation) => map4(
-    all2(
+    all(
       varianceStructContravariantType(type, atLocation, "_ROut"),
       varianceStructCovariantType(type, atLocation, "_E"),
       varianceStructCovariantType(type, atLocation, "_RIn")
@@ -2761,7 +2620,7 @@ function make3(ts, typeChecker) {
     (node) => node
   );
   const effectSchemaVarianceStruct = (type, atLocation) => map4(
-    all2(
+    all(
       varianceStructInvariantType(type, atLocation, "_A"),
       varianceStructInvariantType(type, atLocation, "_I"),
       varianceStructCovariantType(type, atLocation, "_R")
@@ -2793,7 +2652,7 @@ function make3(ts, typeChecker) {
     (type) => type
   );
   const contextTagVarianceStruct = (type, atLocation) => map4(
-    all2(
+    all(
       varianceStructInvariantType(type, atLocation, "_Identifier"),
       varianceStructInvariantType(type, atLocation, "_Service")
     ),
@@ -3071,7 +2930,7 @@ var importFromBarrel = createDiagnostic({
     const typeChecker = yield* service(TypeCheckerApi);
     const program = yield* service(TypeScriptProgram);
     const packageNamesToCheck = flatten(
-      yield* all2(
+      yield* all(
         ...languageServicePluginOptions.namespaceImportPackages.map(
           (packageName) => resolveModulePattern(sourceFile, packageName)
         )
@@ -3323,7 +3182,7 @@ var missingEffectContext = createDiagnostic({
     const typeParser = yield* service(TypeParser);
     const typeOrder = yield* deterministicTypeOrder;
     const checkForMissingContextTypes = (node, expectedType, valueNode, realType) => pipe(
-      all2(
+      all(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
@@ -3389,7 +3248,7 @@ var missingEffectError = createDiagnostic({
       [ts.factory.createStringLiteral(message)]
     );
     const checkForMissingErrorTypes = (node, expectedType, valueNode, realType) => pipe(
-      all2(
+      all(
         typeParser.effectType(expectedType, node),
         typeParser.effectType(realType, valueNode)
       ),
@@ -3631,6 +3490,110 @@ var missingStarInYieldEffectGen = createDiagnostic({
   })
 });
 
+// src/diagnostics/multipleEffectProvide.ts
+var multipleEffectProvide = createDiagnostic({
+  name: "multipleEffectProvide",
+  code: 18,
+  severity: "warning",
+  apply: fn("multipleEffectProvide.apply")(function* (sourceFile, report) {
+    const ts = yield* service(TypeScriptApi);
+    const typeChecker = yield* service(TypeCheckerApi);
+    const typeParser = yield* service(TypeParser);
+    const effectModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Effect"
+      ),
+      map4((_) => _.text),
+      orElse2(() => succeed("Effect"))
+    );
+    const layerModuleIdentifier = yield* pipe(
+      findImportedModuleIdentifierByPackageAndNameOrBarrel(
+        sourceFile,
+        "effect",
+        "Layer"
+      ),
+      map4((_) => _.text),
+      orElse2(() => succeed("Layer"))
+    );
+    const parseEffectProvideLayer = (node) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.name) && node.expression.name.text === "provide" && node.arguments.length > 0) {
+        const layer = node.arguments[0];
+        const type = typeChecker.getTypeAtLocation(layer);
+        return pipe(
+          typeParser.importedEffectModule(node.expression.expression),
+          flatMap2(() => typeParser.layerType(type, layer)),
+          map4(() => ({ layer, node })),
+          orElse2(() => void_)
+        );
+      }
+      return void_;
+    };
+    const parsePipeCall = (node) => gen(function* () {
+      const { args: args2 } = yield* typeParser.pipeCall(node);
+      let currentChunk = 0;
+      const previousLayers = [[]];
+      for (const pipeArg of args2) {
+        const parsedProvide = yield* parseEffectProvideLayer(pipeArg);
+        if (parsedProvide) {
+          previousLayers[currentChunk].push(parsedProvide);
+        } else {
+          currentChunk++;
+          previousLayers.push([]);
+        }
+      }
+      for (const chunk of previousLayers) {
+        if (chunk.length < 2) continue;
+        report({
+          node: chunk[0].node,
+          messageText: "Avoid chaining Effect.provide calls, as this can lead to service lifecycle issues. Instead, merge layers and provide them in a single call.",
+          fixes: [{
+            fixName: "multipleEffectProvide_fix",
+            description: "Combine into a single provide",
+            apply: gen(function* () {
+              const changeTracker = yield* service(ChangeTracker);
+              changeTracker.deleteRange(sourceFile, {
+                pos: chunk[0].node.getStart(sourceFile),
+                end: chunk[chunk.length - 1].node.getEnd()
+              });
+              const newNode = ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier(effectModuleIdentifier),
+                  ts.factory.createIdentifier("provide")
+                ),
+                void 0,
+                [ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier(layerModuleIdentifier),
+                    ts.factory.createIdentifier("mergeAll")
+                  ),
+                  void 0,
+                  chunk.map((c) => c.layer)
+                )]
+              );
+              changeTracker.insertNodeAt(sourceFile, chunk[0].node.getStart(sourceFile), newNode);
+            })
+          }]
+        });
+      }
+    });
+    const nodeToVisit = [];
+    const appendNodeToVisit = (node) => {
+      nodeToVisit.push(node);
+      return void 0;
+    };
+    ts.forEachChild(sourceFile, appendNodeToVisit);
+    while (nodeToVisit.length > 0) {
+      const node = nodeToVisit.shift();
+      ts.forEachChild(node, appendNodeToVisit);
+      if (ts.isCallExpression(node)) {
+        yield* pipe(parsePipeCall(node), ignore);
+      }
+    }
+  })
+});
+
 // src/diagnostics/returnEffectInGen.ts
 var returnEffectInGen = createDiagnostic({
   name: "returnEffectInGen",
@@ -4092,7 +4055,8 @@ var diagnostics = [
   scopeInLayerEffect,
   effectInVoidSuccess,
   unnecessaryPipeChain,
-  strictBooleanExpressions
+  strictBooleanExpressions,
+  multipleEffectProvide
 ];
 
 // src/completions/effectDiagnosticsComment.ts
@@ -4388,41 +4352,6 @@ var completions = [
   schemaBrand
 ];
 
-// node_modules/.pnpm/effect@3.16.12/node_modules/effect/dist/esm/internal/encoding/common.js
-var encoder = /* @__PURE__ */ new TextEncoder();
-
-// node_modules/.pnpm/effect@3.16.12/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/effect@3.16.12/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.16.12/node_modules/effect/dist/esm/Encoding.js
-var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
-
 // src/core/AutoImport.ts
 var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
   const ts = yield* service(TypeScriptApi);
@@ -4481,7 +4410,7 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
       );
       if (!_entrypoints) return;
       if (!isArray(_entrypoints)) return;
-      if (!every2(Predicate_exports.isString)) return;
+      if (!every(isString)) return;
       const entrypoints = _entrypoints.map((_) => String(_));
       const info = parsePackageContentNameAndVersionFromScope({ packageJsonScope: packageJsonInfo });
       if (!info) return { entrypoints, exportedKeys: [] };
@@ -4589,7 +4518,7 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
     if (!moduleSpecifier) return fileName;
     return moduleSpecifier;
   };
-  return (exportFileName, exportName) => {
+  const resolve = (exportFileName, exportName) => {
     const excludedExports = mapFilenameToExportExcludes.get(exportFileName);
     if (excludedExports && excludedExports.includes(exportName)) return;
     const mapToNamespace = mapFromBarrelToNamespace.get(exportFileName);
@@ -4629,10 +4558,166 @@ var makeAutoImportProvider = fn("TypeScriptApi")(function* (fromSourceFile) {
       };
     }
   };
+  const sortText = (exportFileName, exportName) => {
+    const excludedExports = mapFilenameToExportExcludes.get(exportFileName);
+    if (excludedExports && excludedExports.includes(exportName)) return;
+    const mapToNamespace = mapFromBarrelToNamespace.get(exportFileName);
+    if (mapToNamespace && exportName in mapToNamespace) return "99";
+  };
+  return { resolve, sortText };
+});
+var importProvidersCache = /* @__PURE__ */ new Map();
+var getOrMakeAutoImportProvider = fn("getOrMakeAutoImportProvider")(function* (sourceFile) {
+  const autoImportProvider = importProvidersCache.get(sourceFile.fileName) || (yield* makeAutoImportProvider(sourceFile));
+  importProvidersCache.set(sourceFile.fileName, autoImportProvider);
+  return autoImportProvider;
+});
+var parseImportOnlyChanges = fn("parseImportOnlyChanges")(function* (sourceFile, changes) {
+  const ts = yield* service(TypeScriptApi);
+  const deletions = [];
+  const imports = [];
+  for (const change of changes) {
+    if (change.newText.length === 0) {
+      deletions.push(change);
+      continue;
+    }
+    if (change.newText.trim().startsWith("import") && change.newText.trim().includes("from")) {
+      try {
+        const parsedImport = ts.createSourceFile("test.ts", change.newText, sourceFile.languageVersion, false);
+        for (const statement of parsedImport.statements) {
+          if (!ts.isImportDeclaration(statement)) return;
+          const moduleSpecifier = statement.moduleSpecifier;
+          if (!ts.isStringLiteral(moduleSpecifier)) return;
+          const moduleName = moduleSpecifier.text;
+          const importClause = statement.importClause;
+          if (!importClause) return;
+          const namedBindings = importClause.namedBindings;
+          if (!namedBindings) return;
+          if (ts.isNamedImports(namedBindings)) {
+            for (const importSpecifier of namedBindings.elements) {
+              if (!ts.isIdentifier(importSpecifier.name)) return;
+              const exportName = importSpecifier.name.text;
+              imports.push({ moduleName, exportName });
+              continue;
+            }
+          } else if (ts.isNamespaceImport(namedBindings)) {
+            imports.push({ moduleName, exportName: void 0 });
+            continue;
+          }
+        }
+      } catch (_) {
+        return;
+      }
+    } else {
+      const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, {
+        pos: change.span.start,
+        end: change.span.start
+      });
+      const importNodes = ancestorNodes.filter((node) => ts.isImportDeclaration(node));
+      const importNode = importNodes[0];
+      if (!importNode) return;
+      const moduleSpecifier = importNode.moduleSpecifier;
+      if (!ts.isStringLiteral(moduleSpecifier)) return;
+      const moduleName = moduleSpecifier.text;
+      const exportName = change.newText.replace(/,/ig, "").trim();
+      if (exportName.length === 0) return;
+      imports.push({ moduleName, exportName });
+    }
+  }
+  return { deletions, imports };
 });
+var addImport = (ts, sourceFile, changeTracker, preferences, effectAutoImport) => {
+  let description = "";
+  switch (effectAutoImport._tag) {
+    case "NamespaceImport": {
+      const importModule = effectAutoImport.moduleName || effectAutoImport.fileName;
+      description = `Import * as ${effectAutoImport.name} from "${importModule}"`;
+      ts.insertImports(
+        changeTracker,
+        sourceFile,
+        ts.factory.createImportDeclaration(
+          void 0,
+          ts.factory.createImportClause(
+            false,
+            void 0,
+            ts.factory.createNamespaceImport(ts.factory.createIdentifier(effectAutoImport.name))
+          ),
+          ts.factory.createStringLiteral(importModule)
+        ),
+        true,
+        preferences || {}
+      );
+      break;
+    }
+    case "NamedImport": {
+      const importModule = effectAutoImport.moduleName || effectAutoImport.fileName;
+      description = `Import { ${effectAutoImport.name} } from "${importModule}"`;
+      let foundImportDeclaration = false;
+      for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+          const moduleSpecifier = statement.moduleSpecifier;
+          if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === importModule) {
+            const importClause = statement.importClause;
+            if (importClause && importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
+              const namedImports = importClause.namedBindings;
+              const existingImportSpecifier = namedImports.elements.find(
+                (element) => element.name.text === effectAutoImport.name
+              );
+              if (existingImportSpecifier) {
+                foundImportDeclaration = true;
+                break;
+              }
+              changeTracker.replaceNode(
+                sourceFile,
+                namedImports,
+                ts.factory.createNamedImports(
+                  namedImports.elements.concat([
+                    ts.factory.createImportSpecifier(
+                      false,
+                      void 0,
+                      ts.factory.createIdentifier(effectAutoImport.name)
+                    )
+                  ])
+                )
+              );
+              foundImportDeclaration = true;
+              break;
+            }
+          }
+        }
+      }
+      if (!foundImportDeclaration) {
+        ts.insertImports(
+          changeTracker,
+          sourceFile,
+          ts.factory.createImportDeclaration(
+            void 0,
+            ts.factory.createImportClause(
+              false,
+              void 0,
+              ts.factory.createNamedImports(
+                [
+                  ts.factory.createImportSpecifier(
+                    false,
+                    void 0,
+                    ts.factory.createIdentifier(effectAutoImport.name)
+                  )
+                ]
+              )
+            ),
+            ts.factory.createStringLiteral(importModule)
+          ),
+          true,
+          preferences || {}
+        );
+      }
+      break;
+    }
+  }
+  return { description };
+};
 
 // src/completions/middlewareAutoImports.ts
-var importProvidersCache = /* @__PURE__ */ new Map();
 var appendEffectCompletionEntryData = fn("appendEffectCompletionEntryData")(
   function* (_sourceFile, applicableCompletions) {
     const languageServicePluginOptions = yield* service(LanguageServicePluginOptions);
@@ -4656,7 +4741,6 @@ var appendEffectCompletionEntryData = fn("appendEffectCompletionEntryData")(
 );
 var isAutoImportOnlyCodeActions = fn("isAutoImportOnlyCodeActions")(
   function* (sourceFile, codeActions, exportName) {
-    const ts = yield* service(TypeScriptApi);
     if (!codeActions) return;
     if (codeActions.length !== 1) return;
     const action = codeActions[0];
@@ -4665,25 +4749,12 @@ var isAutoImportOnlyCodeActions = fn("isAutoImportOnlyCodeActions")(
     const fileTextChanges = action.changes[0];
     if (fileTextChanges.fileName !== sourceFile.fileName) return;
     const textChanges = fileTextChanges.textChanges;
-    if (textChanges.length !== 1) return;
-    const change = textChanges[0];
-    if (change.newText.trim().toLowerCase().startsWith("import") && change.newText.indexOf(exportName) > -1) {
-      return {
-        type: "create"
-      };
-    }
-    if (change.newText.indexOf(exportName) > -1) {
-      const ancestorNodes = yield* getAncestorNodesInRange(sourceFile, {
-        pos: change.span.start,
-        end: change.span.start
-      });
-      const importNodes = ancestorNodes.filter((node) => ts.isImportDeclaration(node));
-      if (importNodes.length > 0) {
-        return {
-          type: "update"
-        };
-      }
-    }
+    const parsedImportChanges = yield* parseImportOnlyChanges(sourceFile, textChanges);
+    if (!parsedImportChanges) return;
+    if (parsedImportChanges.deletions.length !== 0) return;
+    if (parsedImportChanges.imports.length !== 1) return;
+    if (parsedImportChanges.imports[0].exportName !== exportName) return;
+    return parsedImportChanges.imports[0];
   }
 );
 var addImportCodeAction = fn("getImportFromNamespaceCodeActions")(function* (formatOptions, preferences, languageServiceHost, sourceFile, effectReplaceSpan, effectAutoImport) {
@@ -4707,92 +4778,13 @@ var addImportCodeAction = fn("getImportFromNamespaceCodeActions")(function* (for
           effectAutoImport.introducedPrefix + "."
         );
       }
-      switch (effectAutoImport._tag) {
-        case "NamespaceImport": {
-          const importModule = effectAutoImport.moduleName || effectAutoImport.fileName;
-          description = `Import * as ${effectAutoImport.name} from "${importModule}"`;
-          ts.insertImports(
-            changeTracker,
-            sourceFile,
-            ts.factory.createImportDeclaration(
-              void 0,
-              ts.factory.createImportClause(
-                false,
-                void 0,
-                ts.factory.createNamespaceImport(ts.factory.createIdentifier(effectAutoImport.name))
-              ),
-              ts.factory.createStringLiteral(importModule)
-            ),
-            true,
-            preferences || {}
-          );
-          break;
-        }
-        case "NamedImport": {
-          const importModule = effectAutoImport.moduleName || effectAutoImport.fileName;
-          description = `Import { ${effectAutoImport.name} } from "${importModule}"`;
-          let foundImportDeclaration = false;
-          for (const statement of sourceFile.statements) {
-            if (ts.isImportDeclaration(statement)) {
-              const moduleSpecifier = statement.moduleSpecifier;
-              if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === importModule) {
-                const importClause = statement.importClause;
-                if (importClause && importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
-                  const namedImports = importClause.namedBindings;
-                  const existingImportSpecifier = namedImports.elements.find(
-                    (element) => element.name.text === effectAutoImport.name
-                  );
-                  if (existingImportSpecifier) {
-                    foundImportDeclaration = true;
-                    break;
-                  }
-                  changeTracker.replaceNode(
-                    sourceFile,
-                    namedImports,
-                    ts.factory.createNamedImports(
-                      namedImports.elements.concat([
-                        ts.factory.createImportSpecifier(
-                          false,
-                          void 0,
-                          ts.factory.createIdentifier(effectAutoImport.name)
-                        )
-                      ])
-                    )
-                  );
-                  foundImportDeclaration = true;
-                  break;
-                }
-              }
-            }
-          }
-          if (!foundImportDeclaration) {
-            ts.insertImports(
-              changeTracker,
-              sourceFile,
-              ts.factory.createImportDeclaration(
-                void 0,
-                ts.factory.createImportClause(
-                  false,
-                  void 0,
-                  ts.factory.createNamedImports(
-                    [
-                      ts.factory.createImportSpecifier(
-                        false,
-                        void 0,
-                        ts.factory.createIdentifier(effectAutoImport.name)
-                      )
-                    ]
-                  )
-                ),
-                ts.factory.createStringLiteral(importModule)
-              ),
-              true,
-              preferences || {}
-            );
-          }
-          break;
-        }
-      }
+      description = addImport(
+        ts,
+        sourceFile,
+        changeTracker,
+        preferences,
+        effectAutoImport
+      ).description;
     }
   );
   return [
@@ -4820,9 +4812,8 @@ var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
       exportName
     );
     if (!result) return applicableCompletionEntryDetails;
-    const packagesMetadata = importProvidersCache.get(sourceFile.fileName) || (yield* makeAutoImportProvider(sourceFile));
-    importProvidersCache.set(sourceFile.fileName, packagesMetadata);
-    const effectAutoImport = packagesMetadata(fileName, exportName);
+    const autoImportProvider = yield* getOrMakeAutoImportProvider(sourceFile);
+    const effectAutoImport = autoImportProvider.resolve(fileName, exportName);
     if (!effectAutoImport) return applicableCompletionEntryDetails;
     const codeActions = yield* addImportCodeAction(
       formatOptions,
@@ -4839,6 +4830,74 @@ var postprocessCompletionEntryDetails = fn("postprocessCompletionEntryDetails")(
   }
 );
 
+// src/diagnostics/middlewareAutoImportQuickfixes.ts
+var middlewareAutoImportQuickfixes = fn("middlewareAutoImportQuickfixes")(function* (sourceFile, languageServiceHost, formatOptions, preferences, codeFixes) {
+  const ts = yield* service(TypeScriptApi);
+  const program = yield* service(TypeScriptProgram);
+  const autoImportProvider = yield* getOrMakeAutoImportProvider(sourceFile);
+  const changedCodeFixes = [];
+  const createImportAllChanges = (imports) => gen(function* () {
+    const newImports = [];
+    for (const importToAdd of imports) {
+      if (!importToAdd.exportName) return;
+      const fileName = ts.resolveModuleName(
+        importToAdd.moduleName,
+        sourceFile.fileName,
+        program.getCompilerOptions(),
+        program
+      );
+      if (!fileName.resolvedModule) return;
+      const importKind = autoImportProvider.resolve(fileName.resolvedModule.resolvedFileName, importToAdd.exportName);
+      if (!importKind) return;
+      if (importKind.introducedPrefix) return;
+      newImports.push(importKind);
+    }
+    const formatContext = ts.formatting.getFormatContext(
+      formatOptions,
+      languageServiceHost
+    );
+    const edits = ts.textChanges.ChangeTracker.with(
+      {
+        formatContext,
+        host: languageServiceHost,
+        preferences: preferences || {}
+      },
+      (changeTracker) => newImports.forEach((_) => addImport(ts, sourceFile, changeTracker, preferences, _))
+    );
+    return edits;
+  });
+  for (const codeFix of codeFixes) {
+    const textFileChanges = codeFix.changes;
+    if (textFileChanges.length !== 1) {
+      changedCodeFixes.push(codeFix);
+      continue;
+    }
+    if (textFileChanges[0].fileName !== sourceFile.fileName) {
+      changedCodeFixes.push(codeFix);
+      continue;
+    }
+    const parsedChanges = yield* parseImportOnlyChanges(sourceFile, textFileChanges[0].textChanges);
+    if (!parsedChanges) {
+      changedCodeFixes.push(codeFix);
+      continue;
+    }
+    if (parsedChanges.deletions.length !== 0) {
+      changedCodeFixes.push(codeFix);
+      continue;
+    }
+    const changes = yield* pipe(
+      createImportAllChanges(parsedChanges.imports),
+      orElse2(() => succeed(codeFix.changes))
+    );
+    if (changes) {
+      changedCodeFixes.push({ ...codeFix, changes });
+    } else {
+      changedCodeFixes.push(codeFix);
+    }
+  }
+  return changedCodeFixes;
+});
+
 // src/goto/effectRpcDefinition.ts
 function effectRpcDefinition(applicableGotoDefinition, sourceFile, position) {
   return gen(function* () {
@@ -5062,6 +5121,41 @@ function effectTypeArgs(sourceFile, position, quickInfo2) {
   );
 }
 
+// node_modules/.pnpm/effect@3.17.1/node_modules/effect/dist/esm/internal/encoding/common.js
+var encoder = /* @__PURE__ */ new TextEncoder();
+
+// node_modules/.pnpm/effect@3.17.1/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/effect@3.17.1/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.17.1/node_modules/effect/dist/esm/Encoding.js
+var encodeBase64Url = (input) => typeof input === "string" ? encode2(encoder.encode(input)) : encode2(input);
+
 // node_modules/.pnpm/pako@2.1.0/node_modules/pako/dist/pako.esm.mjs
 var Z_FIXED$1 = 4;
 var Z_BINARY = 0;
@@ -9282,7 +9376,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
       const maybeLayer = yield* option(typeParser.layerType(type, node));
       if (isSome2(maybeLayer)) {
         const argNodes = yield* option(
-          all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+          all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
         );
         if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
           const { allIndexes: outTypes } = yield* appendToUniqueTypesMap(
@@ -9326,7 +9420,7 @@ function processLayerGraphNode(ctx, node, pipedInGraphNode) {
             );
             if (ts.isCallExpression(node)) {
               const argNodes = yield* option(
-                all2(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
+                all(...node.arguments.map((_) => processLayerGraphNode(ctx, _, void 0)))
               );
               if (isSome2(argNodes) && argNodes.value.length === node.arguments.length) {
                 return new GraphNodeCompoundTransform(
@@ -9456,7 +9550,7 @@ function processNodeMermaid(graph, ctx, ctxL) {
         return subgraphDefs;
       }
       case "GraphNodeCompoundTransform": {
-        const childs = flatten(yield* all2(...graph.args.map((_) => processNodeMermaid(_, ctx, ctxL))));
+        const childs = flatten(yield* all(...graph.args.map((_) => processNodeMermaid(_, ctx, ctxL))));
         let currentEdges = [];
         const connectedNodes = /* @__PURE__ */ new Set();
         for (const requiredServiceKey of graph.rin) {
@@ -10241,7 +10335,7 @@ var pipeableToDatafirst = createRefactor({
       for (let i = 0; i < callSignatures.length; i++) {
         const callSignature = callSignatures[i];
         if (callSignature.parameters.length === node2.arguments.length + 1) {
-          return some3(
+          return some2(
             ts.factory.createCallExpression(
               node2.expression,
               [],
@@ -10283,7 +10377,7 @@ var pipeableToDatafirst = createRefactor({
             }
           }
         }
-        return didSomething ? some3([node2, newNode2]) : none2();
+        return didSomething ? some2([node2, newNode2]) : none2();
       }),
       filter(isSome2),
       map3((_) => _.value),
@@ -10611,17 +10705,17 @@ var makeSchemaGenContext = fn("SchemaGen.makeSchemaGenContext")(function* (sourc
           case "Pick":
           case "Omit":
           case "Record":
-            return some3(name.text);
+            return some2(name.text);
           case "ReadonlyArray":
           case "Array":
-            return some3("Array");
+            return some2("Array");
         }
         return none2();
       }
       if (!ts.isIdentifier(name.left)) return none2();
       for (const moduleName in moduleToImportedName) {
         if (name.left.text === moduleToImportedName[moduleName] && name.right.text === moduleName) {
-          return some3(moduleName);
+          return some2(moduleName);
         }
       }
       return none2();
@@ -10660,7 +10754,7 @@ var parseAllLiterals = fn(
       }
     }
     if (ts.isUnionTypeNode(node)) {
-      return flatten(yield* all2(...node.types.map((_) => parseAllLiterals(_))));
+      return flatten(yield* all(...node.types.map((_) => parseAllLiterals(_))));
     }
     if (ts.isParenthesizedTypeNode(node)) {
       return yield* parseAllLiterals(node.type);
@@ -10707,11 +10801,11 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
   if (ts.isUnionTypeNode(node)) {
     const allLiterals = yield* option(parseAllLiterals(node));
     if (isSome2(allLiterals)) return createApiCall("Literal", allLiterals.value);
-    const members = yield* all2(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
+    const members = yield* all(...node.types.map((_) => processNode(_, isVirtualTypeNode)));
     return createApiCall("Union", members);
   }
   if (ts.isIntersectionTypeNode(node)) {
-    const [firstSchema, ...otherSchemas] = yield* all2(
+    const [firstSchema, ...otherSchemas] = yield* all(
       ...node.types.map((_) => processNode(_, isVirtualTypeNode))
     );
     if (otherSchemas.length === 0) return firstSchema;
@@ -10767,13 +10861,13 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
         case "Option":
         case "Chunk":
         case "Array": {
-          const elements = yield* all2(
+          const elements = yield* all(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           return createApiCall(parsedName.value, elements);
         }
         case "Record": {
-          const elements = yield* all2(
+          const elements = yield* all(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
@@ -10787,7 +10881,7 @@ var processNode = (node, isVirtualTypeNode) => gen(function* () {
           return createUnsupportedNodeComment(ts, sourceFile, node);
         }
         case "Either": {
-          const elements = yield* all2(
+          const elements = yield* all(
             ...node.typeArguments ? node.typeArguments.map((_) => processNode(_, isVirtualTypeNode)) : []
           );
           if (elements.length >= 2) {
@@ -11494,45 +11588,60 @@ var init = (modules) => {
         preferences,
         ...args2
       );
-      if (languageServicePluginOptions.diagnostics) {
-        return pipe(
-          sync(() => {
-            const effectCodeFixes = [];
-            if (!effectCodeFixesForFile.has(fileName)) {
-              runDiagnosticsAndCacheCodeFixes(fileName);
-            }
-            const applicableFixes = (effectCodeFixesForFile.get(fileName) || []).filter(
-              (_) => _.start === start && _.end === end && errorCodes.indexOf(_.code) > -1
-            );
-            const formatContext = modules.typescript.formatting.getFormatContext(
-              formatOptions,
-              info.languageServiceHost
-            );
-            for (const applicableFix of applicableFixes) {
-              const changes = modules.typescript.textChanges.ChangeTracker.with(
-                {
-                  formatContext,
-                  host: info.languageServiceHost,
-                  preferences: preferences || {}
-                },
-                (changeTracker) => pipe(
-                  applicableFix.apply,
-                  provideService(ChangeTracker, changeTracker),
-                  run
-                )
+      const program = languageService.getProgram();
+      if (languageServicePluginOptions.diagnostics && program) {
+        const sourceFile = program.getSourceFile(fileName);
+        if (sourceFile) {
+          return pipe(
+            sync(() => {
+              const effectCodeFixes = [];
+              if (!effectCodeFixesForFile.has(fileName)) {
+                runDiagnosticsAndCacheCodeFixes(fileName);
+              }
+              const applicableFixes = (effectCodeFixesForFile.get(fileName) || []).filter(
+                (_) => _.start === start && _.end === end && errorCodes.indexOf(_.code) > -1
               );
-              effectCodeFixes.push({
-                fixName: applicableFix.fixName,
-                description: applicableFix.description,
-                changes
-              });
-            }
-            return effectCodeFixes;
-          }),
-          run,
-          map((effectCodeFixes) => applicableCodeFixes.concat(effectCodeFixes)),
-          getOrElse(() => applicableCodeFixes)
-        );
+              const formatContext = modules.typescript.formatting.getFormatContext(
+                formatOptions,
+                info.languageServiceHost
+              );
+              for (const applicableFix of applicableFixes) {
+                const changes = modules.typescript.textChanges.ChangeTracker.with(
+                  {
+                    formatContext,
+                    host: info.languageServiceHost,
+                    preferences: preferences || {}
+                  },
+                  (changeTracker) => pipe(
+                    applicableFix.apply,
+                    provideService(ChangeTracker, changeTracker),
+                    run
+                  )
+                );
+                effectCodeFixes.push({
+                  fixName: applicableFix.fixName,
+                  description: applicableFix.description,
+                  changes
+                });
+              }
+              return effectCodeFixes;
+            }),
+            flatMap2(
+              (effectCodeFixes) => pipe(
+                middlewareAutoImportQuickfixes(
+                  sourceFile,
+                  info.languageServiceHost,
+                  formatOptions,
+                  preferences,
+                  applicableCodeFixes
+                ),
+                map4((modifiedCodeFixes) => effectCodeFixes.concat(modifiedCodeFixes))
+              )
+            ),
+            runNano(program),
+            getOrElse(() => applicableCodeFixes)
+          );
+        }
       }
       return applicableCodeFixes;
     };